Ice::StringSeq
ReplicaGroupFilterI::filter(const string& /* replicaGroupId */,
const Ice::StringSeq& adapters,
const Ice::ConnectionPtr&,
const Ice::Context& ctx)
{
Ice::Context::const_iterator p = ctx.find("currency");
if(p == ctx.end())
{
return adapters;
}
string currency = p->second;
//
// Get the Currencies property value from the server descriptor
// that owns the adapter and only keep adapters for servers that
// are configured with the currency specified in the client
// context.
//
Ice::StringSeq filteredAdapters;
for(Ice::StringSeq::const_iterator p = adapters.begin(); p != adapters.end(); ++p)
{
if(_facade->getPropertyForAdapter(*p, "Currencies").find(currency) != string::npos)
{
filteredAdapters.push_back(*p);
}
}
return filteredAdapters;
}
bool AgentAdapter::init(const ::Ice::StringSeq& defaultAgents,const bool is_udp_protocol, const bool is_compress)
{
if (defaultAgents.empty())
{
XLOG_ERROR("AgentAdapter::init defaultAgent is empty!");
return false;
}
srand(unsigned(time(NULL)));
Ice::PropertiesPtr props=Ice::createProperties();
props->setProperty("Ice.MessageSizeMax", ICE_MESSAGE_SIZE_MAX);
props->setProperty("Ice.Override.Timeout", ICE_TIMEOUT_MILLISECONDS);
Ice::InitializationData id;
id.properties=props;
_ic = ::Ice::initialize(id);
srand((unsigned) time(NULL));
current_agent_prx_number=0;
std::vector<slice::AgentPrx> _prxs;
for (::Ice::StringSeq::const_iterator it = defaultAgents.begin(); it != defaultAgents.end();
++it)
{
slice::AgentPrx prx = Util::getPrx<slice::AgentPrx>(_ic, *it, is_udp_protocol, 1000, is_compress);
_prxs.push_back(prx);
}
agent_prxs.swap(_prxs);
return true;
}
void
LibraryI::remove(const BookDescription& description)
{
IceUtil::Mutex::Lock lock(*this);
//
// Note: no need to catch and retry on deadlock since all access to
// _authors is serialized.
//
try
{
StringIsbnSeqDict::iterator p = _authors.find(description.authors);
assert(p != _authors.end());
//
// Remove the isbn number from the sequence.
//
Ice::StringSeq isbnSeq = p->second;
isbnSeq.erase(remove_if(isbnSeq.begin(), isbnSeq.end(), bind2nd(equal_to<string>(), description.isbn)),
isbnSeq.end());
if(isbnSeq.empty())
{
//
// If there are no further associated isbn numbers then remove
// the record.
//
_authors.erase(p);
}
else
{
//
// Otherwise, write back the new record.
//
p.set(isbnSeq);
}
//
// This can throw EvictorDeactivatedException (which indicates
// an internal error). The exception is currently ignored.
//
_evictor->remove(createBookIdentity(description.isbn));
}
catch(const Freeze::DatabaseException& ex)
{
DatabaseException e;
e.message = ex.message;
throw e;
}
}
void
NodeI::checkConsistency(const NodeSessionPrx& session)
{
//
// Only do the consistency check on the startup. This ensures that servers can't
// be removed by a bogus master when the master session is re-established.
//
if(_consistencyCheckDone)
{
return;
}
_consistencyCheckDone = true;
//
// We use a serial number to keep track of the concurrent changes
// on the node. When a server is loaded/destroyed the serial is
// incremented. This allows to ensure that the list of servers
// returned by the registry is consistent with the servers
// currently deployed on the node: if the serial didn't change
// after getting the list of servers from the registry, we have
// the accurate list of servers that should be deployed on the
// node.
//
unsigned long serial = 0;
Ice::StringSeq servers;
vector<ServerCommandPtr> commands;
while(true)
{
{
Lock sync(*this);
if(serial == _serial)
{
_serial = 1; // We can reset the serial number.
commands = checkConsistencyNoSync(servers);
break;
}
serial = _serial;
}
assert(session);
try
{
servers = session->getServers();
}
catch(const Ice::LocalException&)
{
return; // The connection with the session was lost.
}
sort(servers.begin(), servers.end());
}
for_each(commands.begin(), commands.end(), IceUtil::voidMemFun(&ServerCommand::execute));
}
bool
IcePHP::createStringArray(zval* zv, const Ice::StringSeq& seq)
{
array_init(zv);
for(Ice::StringSeq::const_iterator p = seq.begin(); p != seq.end(); ++p)
{
if(add_next_index_stringl(zv, STRCAST(p->c_str()), static_cast<uint>(p->length())) == FAILURE)
{
return false;
}
}
return true;
}
bool
IcePy::stringSeqToList(const Ice::StringSeq& seq, PyObject* l)
{
assert(PyList_Check(l));
for(Ice::StringSeq::const_iterator p = seq.begin(); p != seq.end(); ++p)
{
PyObject* str = Py_BuildValue(STRCAST("s"), p->c_str());
if(!str)
{
Py_DECREF(l);
return false;
}
int status = PyList_Append(l, str);
Py_DECREF(str); // Give ownership to the list.
if(status < 0)
{
Py_DECREF(l);
return false;
}
}
return true;
}
PyObject*
IcePy_loadSlice(PyObject* /*self*/, PyObject* args)
{
char* cmd;
PyObject* list = 0;
if(!PyArg_ParseTuple(args, STRCAST("s|O!"), &cmd, &PyList_Type, &list))
{
return 0;
}
vector<string> argSeq;
try
{
argSeq = IceUtilInternal::Options::split(cmd);
}
catch(const IceUtilInternal::BadOptException& ex)
{
PyErr_Format(PyExc_RuntimeError, "error in Slice options: %s", ex.reason.c_str());
return 0;
}
catch(const IceUtilInternal::APIException& ex)
{
PyErr_Format(PyExc_RuntimeError, "error in Slice options: %s", ex.reason.c_str());
return 0;
}
if(list)
{
if(!listToStringSeq(list, argSeq))
{
return 0;
}
}
IceUtilInternal::Options opts;
opts.addOpt("D", "", IceUtilInternal::Options::NeedArg, "", IceUtilInternal::Options::Repeat);
opts.addOpt("U", "", IceUtilInternal::Options::NeedArg, "", IceUtilInternal::Options::Repeat);
opts.addOpt("I", "", IceUtilInternal::Options::NeedArg, "", IceUtilInternal::Options::Repeat);
opts.addOpt("d", "debug");
opts.addOpt("", "ice");
opts.addOpt("", "underscore");
opts.addOpt("", "checksum");
opts.addOpt("", "all");
vector<string> files;
try
{
argSeq.insert(argSeq.begin(), ""); // dummy argv[0]
files = opts.parse(argSeq);
if(files.empty())
{
PyErr_Format(PyExc_RuntimeError, "no Slice files specified in `%s'", cmd);
return 0;
}
}
catch(const IceUtilInternal::BadOptException& ex)
{
PyErr_Format(PyExc_RuntimeError, "error in Slice options: %s", ex.reason.c_str());
return 0;
}
catch(const IceUtilInternal::APIException& ex)
{
PyErr_Format(PyExc_RuntimeError, "error in Slice options: %s", ex.reason.c_str());
return 0;
}
vector<string> cppArgs;
Ice::StringSeq includePaths;
bool debug = false;
bool ice = true; // This must be true so that we can create Ice::Identity when necessary.
bool underscore = opts.isSet("underscore");
bool all = false;
bool checksum = false;
if(opts.isSet("D"))
{
vector<string> optargs = opts.argVec("D");
for(vector<string>::const_iterator i = optargs.begin(); i != optargs.end(); ++i)
{
cppArgs.push_back("-D" + *i);
}
}
if(opts.isSet("U"))
{
vector<string> optargs = opts.argVec("U");
for(vector<string>::const_iterator i = optargs.begin(); i != optargs.end(); ++i)
{
cppArgs.push_back("-U" + *i);
}
}
if(opts.isSet("I"))
{
includePaths = opts.argVec("I");
for(vector<string>::const_iterator i = includePaths.begin(); i != includePaths.end(); ++i)
{
cppArgs.push_back("-I" + *i);
}
}
debug = opts.isSet("d") || opts.isSet("debug");
all = opts.isSet("all");
checksum = opts.isSet("checksum");
bool ignoreRedefs = false;
bool keepComments = true;
for(vector<string>::const_iterator p = files.begin(); p != files.end(); ++p)
{
string file = *p;
Slice::PreprocessorPtr icecpp = Slice::Preprocessor::create("icecpp", file, cppArgs);
FILE* cppHandle = icecpp->preprocess(keepComments, "-D__SLICE2PY__");
if(cppHandle == 0)
{
PyErr_Format(PyExc_RuntimeError, "Slice preprocessing failed for `%s'", cmd);
return 0;
}
UnitPtr u = Slice::Unit::createUnit(ignoreRedefs, all, ice, underscore);
int parseStatus = u->parse(file, cppHandle, debug);
if(!icecpp->close() || parseStatus == EXIT_FAILURE)
{
PyErr_Format(PyExc_RuntimeError, "Slice parsing failed for `%s'", cmd);
u->destroy();
return 0;
}
//
// Generate the Python code into a string stream.
//
ostringstream codeStream;
IceUtilInternal::Output out(codeStream);
out.setUseTab(false);
//
// Emit a Python magic comment to set the file encoding.
// It must be the first or second line.
//
out << "# -*- coding: utf-8 -*-\n";
generate(u, all, checksum, includePaths, out);
u->destroy();
string code = codeStream.str();
//
// We need to invoke Ice.updateModules() so that all of the types we've just generated
// are made "public".
//
code += "\nIce.updateModules()\n";
PyObjectHandle src = Py_CompileString(const_cast<char*>(code.c_str()), const_cast<char*>(file.c_str()),
Py_file_input);
if(!src.get())
{
return 0;
}
PyObjectHandle globals = PyDict_New();
if(!globals.get())
{
return 0;
}
PyDict_SetItemString(globals.get(), "__builtins__", PyEval_GetBuiltins());
#if PY_VERSION_HEX >= 0x03000000
PyObjectHandle val = PyEval_EvalCode(src.get(), globals.get(), 0);
#else
PyObjectHandle val = PyEval_EvalCode(reinterpret_cast<PyCodeObject*>(src.get()), globals.get(), 0);
#endif
if(!val.get())
{
return 0;
}
}
Py_INCREF(Py_None);
return Py_None;
}
static int
communicatorInit(CommunicatorObject* self, PyObject* args, PyObject* /*kwds*/)
{
//
// The argument options are:
//
// Ice.initialize()
// Ice.initialize(args)
// Ice.initialize(initData)
// Ice.initialize(configFile)
// Ice.initialize(args, initData)
// Ice.initialize(args, configFile)
//
PyObject* arg1 = 0;
PyObject* arg2 = 0;
if(!PyArg_ParseTuple(args, STRCAST("|OO"), &arg1, &arg2))
{
return -1;
}
PyObject* argList = 0;
PyObject* initData = 0;
PyObject* configFile = 0;
if(arg1 == Py_None)
{
arg1 = 0;
}
if(arg2 == Py_None)
{
arg2 = 0;
}
PyObject* initDataType = lookupType("Ice.InitializationData");
if(arg1)
{
if(PyList_Check(arg1))
{
argList = arg1;
}
else if(PyObject_IsInstance(arg1, initDataType))
{
initData = arg1;
}
else if(checkString(arg1))
{
configFile = arg1;
}
else
{
PyErr_Format(PyExc_ValueError,
STRCAST("initialize expects an argument list, Ice.InitializationData or a configuration filename"));
return -1;
}
}
if(arg2)
{
if(PyList_Check(arg2))
{
if(argList)
{
PyErr_Format(PyExc_ValueError, STRCAST("unexpected list argument to initialize"));
return -1;
}
argList = arg2;
}
else if(PyObject_IsInstance(arg2, initDataType))
{
if(initData)
{
PyErr_Format(PyExc_ValueError, STRCAST("unexpected Ice.InitializationData argument to initialize"));
return -1;
}
initData = arg2;
}
else if(checkString(arg2))
{
if(configFile)
{
PyErr_Format(PyExc_ValueError, STRCAST("unexpected string argument to initialize"));
return -1;
}
configFile = arg2;
}
else
{
PyErr_Format(PyExc_ValueError,
STRCAST("initialize expects an argument list, Ice.InitializationData or a configuration filename"));
return -1;
}
}
if(initData && configFile)
{
PyErr_Format(PyExc_ValueError,
STRCAST("initialize accepts either Ice.InitializationData or a configuration filename"));
return -1;
}
Ice::StringSeq seq;
if(argList && !listToStringSeq(argList, seq))
{
return -1;
}
Ice::InitializationData data;
DispatcherPtr dispatcherWrapper;
try
{
if(initData)
{
PyObjectHandle properties = getAttr(initData, "properties", false);
PyObjectHandle logger = getAttr(initData, "logger", false);
PyObjectHandle threadHook = getAttr(initData, "threadHook", false);
PyObjectHandle threadStart = getAttr(initData, "threadStart", false);
PyObjectHandle threadStop = getAttr(initData, "threadStop", false);
PyObjectHandle batchRequestInterceptor = getAttr(initData, "batchRequestInterceptor", false);
PyObjectHandle dispatcher = getAttr(initData, "dispatcher", false);
if(properties.get())
{
//
// Get the properties implementation.
//
PyObjectHandle impl = getAttr(properties.get(), "_impl", false);
assert(impl.get());
data.properties = getProperties(impl.get());
}
if(logger.get())
{
data.logger = new LoggerWrapper(logger.get());
}
if(threadHook.get() || threadStart.get() || threadStop.get())
{
data.threadHook = new ThreadHook(threadHook.get(), threadStart.get(), threadStop.get());
}
if(dispatcher.get())
{
dispatcherWrapper = new Dispatcher(dispatcher.get());
data.dispatcher = dispatcherWrapper;
}
if(batchRequestInterceptor.get())
{
data.batchRequestInterceptor = new BatchRequestInterceptor(batchRequestInterceptor.get());
}
}
//
// We always supply our own implementation of ValueFactoryManager.
//
data.valueFactoryManager = new ValueFactoryManager;
if(!data.properties)
{
data.properties = Ice::createProperties();
}
if(configFile)
{
data.properties->load(getString(configFile));
}
if(argList)
{
data.properties = Ice::createProperties(seq, data.properties);
}
}
catch(const Ice::Exception& ex)
{
setPythonException(ex);
return -1;
}
//
// Remaining command line options are passed to the communicator
// as an argument vector in case they contain plug-in properties.
//
int argc = static_cast<int>(seq.size());
char** argv = new char*[argc + 1];
int i = 0;
for(Ice::StringSeq::const_iterator s = seq.begin(); s != seq.end(); ++s, ++i)
{
argv[i] = strdup(s->c_str());
}
argv[argc] = 0;
data.compactIdResolver = new IdResolver;
Ice::CommunicatorPtr communicator;
try
{
AllowThreads allowThreads;
if(argList)
{
communicator = Ice::initialize(argc, argv, data);
}
else
{
communicator = Ice::initialize(data);
}
}
catch(const Ice::Exception& ex)
{
for(i = 0; i < argc; ++i)
{
free(argv[i]);
}
delete[] argv;
setPythonException(ex);
return -1;
}
//
// Replace the contents of the given argument list with the filtered arguments.
//
if(argList)
{
PyList_SetSlice(argList, 0, PyList_Size(argList), 0); // Clear the list.
for(i = 0; i < argc; ++i)
{
PyObjectHandle str = Py_BuildValue(STRCAST("s"), argv[i]);
PyList_Append(argList, str.get());
}
}
for(i = 0; i < argc; ++i)
{
free(argv[i]);
}
delete[] argv;
self->communicator = new Ice::CommunicatorPtr(communicator);
CommunicatorMap::iterator p = _communicatorMap.find(communicator);
if(p != _communicatorMap.end())
{
_communicatorMap.erase(p);
}
_communicatorMap.insert(CommunicatorMap::value_type(communicator, reinterpret_cast<PyObject*>(self)));
if(dispatcherWrapper)
{
self->dispatcher = new DispatcherPtr(dispatcherWrapper);
dispatcherWrapper->setCommunicator(communicator);
}
return 0;
}
int
Activator::activate(const string& name,
const string& exePath,
const string& pwdPath,
#ifndef _WIN32
uid_t uid,
gid_t gid,
#endif
const Ice::StringSeq& options,
const Ice::StringSeq& envs,
const ServerIPtr& server)
{
IceUtil::Monitor< IceUtil::Mutex>::Lock sync(*this);
if(_deactivating)
{
throw string("The node is being shutdown.");
}
string path = exePath;
if(path.empty())
{
throw string("The server executable path is empty.");
}
string pwd = IcePatch2Internal::simplify(pwdPath);
#ifdef _WIN32
if(!IceUtilInternal::isAbsolutePath(path))
{
if(path.find('/') == string::npos)
{
//
// Get the absolute pathname of the executable.
//
wchar_t absbuf[_MAX_PATH];
wchar_t* fPart;
wstring ext = path.size() <= 4 || path[path.size() - 4] != '.' ? L".exe" : L"";
//
// IceGrid doesn't support to use string converters, so don't need to use
// any string converter in wstringToString conversions.
//
if(SearchPathW(NULL, IceUtil::stringToWstring(path).c_str(), ext.c_str(), _MAX_PATH, absbuf, &fPart) == 0)
{
if(_traceLevels->activator > 0)
{
Trace out(_traceLevels->logger, _traceLevels->activatorCat);
out << "couldn't find `" << path << "' executable.";
}
throw string("Couldn't find `" + path + "' executable.");
}
path = IceUtil::wstringToString(absbuf);
}
else if(!pwd.empty())
{
path = pwd + "/" + path;
}
}
//
// Get the absolute pathname of the working directory.
//
// IceGrid doesn't support to use string converters, so
// don't need to use any string converter in stringToWstring
// conversions.
//
if(!pwd.empty())
{
wchar_t absbuf[_MAX_PATH];
if(_wfullpath(absbuf, IceUtil::stringToWstring(pwd).c_str(), _MAX_PATH) == NULL)
{
if(_traceLevels->activator > 0)
{
Trace out(_traceLevels->logger, _traceLevels->activatorCat);
out << "cannot convert `" << pwd << "' into an absolute path";
}
throw string("The server working directory path `" + pwd + "' can't be converted into an absolute path.");
}
pwd = IceUtil::wstringToString(absbuf);
}
#endif
//
// Setup arguments.
//
StringSeq args;
args.push_back(path);
args.insert(args.end(), options.begin(), options.end());
if(_traceLevels->activator > 0)
{
Ice::Trace out(_traceLevels->logger, _traceLevels->activatorCat);
out << "activating server `" << name << "'";
if(_traceLevels->activator > 1)
{
out << "\n";
out << "path = " << path << "\n";
if(pwd.empty())
{
string cwd;
if(IceUtilInternal::getcwd(cwd) == 0)
{
out << "pwd = " << cwd << "\n";
}
}
else
{
out << "pwd = " << pwd << "\n";
}
#ifndef _WIN32
out << "uid/gid = " << uid << "/" << gid << "\n";
#endif
if(!envs.empty())
{
out << "envs = " << toString(envs, ", ") << "\n";
}
if(!args.empty())
{
out << "args = " << toString(args);
}
}
}
//
// Activate and create.
//
#ifdef _WIN32
//
// Compose command line.
//
string cmd;
for(StringSeq::const_iterator p = args.begin(); p != args.end(); ++p)
{
if(p != args.begin())
{
cmd.push_back(' ');
}
//
// Enclose arguments containing spaces in double quotes.
//
if((*p).find(' ') != string::npos)
{
cmd.push_back('"');
cmd.append(*p);
cmd.push_back('"');
}
else
{
cmd.append(*p);
}
}
//
// IceGrid doesn't support to use string converters, so don't need to use
// any string converter in stringToWstring conversions.
//
wstring wpwd = IceUtil::stringToWstring(pwd);
const wchar_t* dir = !wpwd.empty() ? wpwd.c_str() : NULL;
//
// Make a copy of the command line.
//
wchar_t* cmdbuf = _wcsdup(IceUtil::stringToWstring(cmd).c_str());
//
// Create the environment block for the child process. We start with the environment
// of this process, and then merge environment variables from the server description.
// Since Windows is case insensitive wrt environment variables we convert the keys to
// uppercase to ensure matches are found.
//
const wchar_t* env = NULL;
wstring envbuf;
if(!envs.empty())
{
map<wstring, wstring, UnicodeStringLess> envMap;
LPVOID parentEnv = GetEnvironmentStringsW();
const wchar_t* var = reinterpret_cast<const wchar_t*>(parentEnv);
if(*var == L'=')
{
//
// The environment block may start with some information about the
// current drive and working directory. This is indicated by a leading
// '=' character, so we skip to the first '\0' byte.
//
while(*var != L'\0')
var++;
var++;
}
while(*var != L'\0')
{
wstring s(var);
wstring::size_type pos = s.find(L'=');
if(pos != wstring::npos)
{
envMap[s.substr(0, pos)] = s.substr(pos + 1);
}
var += s.size();
var++; // Skip the '\0' byte
}
FreeEnvironmentStringsW(static_cast<wchar_t*>(parentEnv));
for(StringSeq::const_iterator p = envs.begin(); p != envs.end(); ++p)
{
//
// IceGrid doesn't support to use string converters, so don't need to use
// any string converter in stringToWstring conversions.
//
wstring s = IceUtil::stringToWstring(*p);
wstring::size_type pos = s.find(L'=');
if(pos != wstring::npos)
{
envMap[s.substr(0, pos)] = s.substr(pos + 1);
}
}
for(map<wstring, wstring, UnicodeStringLess>::const_iterator q = envMap.begin(); q != envMap.end(); ++q)
{
envbuf.append(q->first);
envbuf.push_back(L'=');
envbuf.append(q->second);
envbuf.push_back(L'\0');
}
envbuf.push_back(L'\0');
env = envbuf.c_str();
}
Process process;
STARTUPINFOW si;
ZeroMemory(&si, sizeof(si));
si.cb = sizeof(si);
PROCESS_INFORMATION pi;
ZeroMemory(&pi, sizeof(pi));
BOOL b = CreateProcessW(
NULL, // Executable
cmdbuf, // Command line
NULL, // Process attributes
NULL, // Thread attributes
FALSE, // Do NOT inherit handles
CREATE_NEW_PROCESS_GROUP | CREATE_UNICODE_ENVIRONMENT, // Process creation flags
(LPVOID)env, // Process environment
dir, // Current directory
&si, // Startup info
&pi // Process info
);
free(cmdbuf);
if(!b)
{
throw IceUtilInternal::lastErrorToString();
}
//
// Caller is responsible for closing handles in PROCESS_INFORMATION. We don't need to
// keep the thread handle, so we close it now. The process handle will be closed later.
//
CloseHandle(pi.hThread);
process.activator = this;
process.pid = pi.dwProcessId;
process.hnd = pi.hProcess;
process.server = server;
map<string, Process>::iterator it = _processes.insert(make_pair(name, process)).first;
Process* pp = &it->second;
if(!RegisterWaitForSingleObject(&pp->waithnd, pp->hnd, activatorWaitCallback, pp, INFINITE,
WT_EXECUTEDEFAULT | WT_EXECUTEONLYONCE))
{
throw IceUtilInternal::lastErrorToString();
}
//
// Don't print the following trace, this might interfer with the
// output of the started process if it fails with an error message.
//
// if(_traceLevels->activator > 0)
// {
// Ice::Trace out(_traceLevels->logger, _traceLevels->activatorCat);
// out << "activated server `" << name << "' (pid = " << pi.dwProcessId << ")";
// }
return static_cast<Ice::Int>(process.pid);
#else
int fds[2];
if(pipe(fds) != 0)
{
SyscallException ex(__FILE__, __LINE__);
ex.error = getSystemErrno();
throw ex;
}
int errorFds[2];
if(pipe(errorFds) != 0)
{
SyscallException ex(__FILE__, __LINE__);
ex.error = getSystemErrno();
throw ex;
}
//
// Convert to standard argc/argv.
//
IceUtilInternal::ArgVector av(args);
IceUtilInternal::ArgVector env(envs);
//
// Current directory
//
const char* pwdCStr = pwd.c_str();
pid_t pid = fork();
if(pid == -1)
{
SyscallException ex(__FILE__, __LINE__);
ex.error = getSystemErrno();
throw ex;
}
if(pid == 0) // Child process.
{
//
// Until exec, we can only use async-signal safe functions
//
//
// Unblock signals blocked by IceUtil::CtrlCHandler.
//
sigset_t sigs;
sigemptyset(&sigs);
sigaddset(&sigs, SIGHUP);
sigaddset(&sigs, SIGINT);
sigaddset(&sigs, SIGTERM);
sigprocmask(SIG_UNBLOCK, &sigs, 0);
//
// Change the uid/gid under which the process will run.
//
if(setgid(gid) == -1)
{
ostringstream os;
os << gid;
reportChildError(getSystemErrno(), errorFds[1], "cannot set process group id", os.str().c_str(),
_traceLevels);
}
errno = 0;
struct passwd* pw = getpwuid(uid);
if(!pw)
{
if(errno)
{
reportChildError(getSystemErrno(), errorFds[1], "cannot read the password database", "",
_traceLevels);
}
else
{
ostringstream os;
os << uid;
reportChildError(getSystemErrno(), errorFds[1], "unknown user uid" , os.str().c_str(),
_traceLevels);
}
}
//
// Don't initialize supplementary groups if we are not running as root.
//
if(getuid() == 0 && initgroups(pw->pw_name, gid) == -1)
{
ostringstream os;
os << pw->pw_name;
reportChildError(getSystemErrno(), errorFds[1], "cannot initialize process supplementary group access list for user",
os.str().c_str(), _traceLevels);
}
if(setuid(uid) == -1)
{
ostringstream os;
os << uid;
reportChildError(getSystemErrno(), errorFds[1], "cannot set process user id", os.str().c_str(),
_traceLevels);
}
//
// Assign a new process group for this process.
//
setpgid(0, 0);
//
// Close all file descriptors, except for standard input,
// standard output, standard error, and the write side
// of the newly created pipe.
//
int maxFd = static_cast<int>(sysconf(_SC_OPEN_MAX));
for(int fd = 3; fd < maxFd; ++fd)
{
if(fd != fds[1] && fd != errorFds[1])
{
close(fd);
}
}
for(int i = 0; i < env.argc; i++)
{
//
// Each env is leaked on purpose ... see man putenv().
//
if(putenv(strdup(env.argv[i])) != 0)
{
reportChildError(errno, errorFds[1], "cannot set environment variable", env.argv[i],
_traceLevels);
}
}
//
// Change working directory.
//
if(strlen(pwdCStr) != 0)
{
if(chdir(pwdCStr) == -1)
{
reportChildError(errno, errorFds[1], "cannot change working directory to", pwdCStr,
_traceLevels);
}
}
//
// Close on exec the error message file descriptor.
//
int flags = fcntl(errorFds[1], F_GETFD);
flags |= 1; // FD_CLOEXEC
if(fcntl(errorFds[1], F_SETFD, flags) == -1)
{
close(errorFds[1]);
errorFds[1] = -1;
}
if(execvp(av.argv[0], av.argv) == -1)
{
if(errorFds[1] != -1)
{
reportChildError(errno, errorFds[1], "cannot execute", av.argv[0], _traceLevels);
}
else
{
reportChildError(errno, fds[1], "cannot execute", av.argv[0], _traceLevels);
}
}
}
else // Parent process.
{
close(fds[1]);
close(errorFds[1]);
//
// Read a potential error message over the error message pipe.
//
char s[16];
ssize_t rs;
string message;
while((rs = read(errorFds[0], &s, 16)) > 0)
{
message.append(s, rs);
}
//
// If an error occured before the exec() we do some cleanup and throw.
//
if(!message.empty())
{
close(fds[0]);
close(errorFds[0]);
waitPid(pid);
throw message;
}
//
// Otherwise, the exec() was successfull and we don't need the error message
// pipe anymore.
//
close(errorFds[0]);
Process process;
process.pid = pid;
process.pipeFd = fds[0];
process.server = server;
_processes.insert(make_pair(name, process));
int flags = fcntl(process.pipeFd, F_GETFL);
flags |= O_NONBLOCK;
fcntl(process.pipeFd, F_SETFL, flags);
setInterrupt();
//
// Don't print the following trace, this might interfere with the
// output of the started process if it fails with an error message.
//
// if(_traceLevels->activator > 0)
// {
// Ice::Trace out(_traceLevels->logger, _traceLevels->activatorCat);
// out << "activated server `" << name << "' (pid = " << pid << ")";
// }
}
return pid;
#endif
}
static int
communicatorInit(CommunicatorObject* self, PyObject* args, PyObject* /*kwds*/)
{
PyObject* argList = 0;
PyObject* initData = 0;
if(!PyArg_ParseTuple(args, STRCAST("|OO"), &argList, &initData))
{
return -1;
}
if(argList == Py_None)
{
argList = 0;
}
if(initData == Py_None)
{
initData = 0;
}
PyObject* initDataType = lookupType("Ice.InitializationData");
if(argList && !initData)
{
if(PyObject_IsInstance(argList, initDataType))
{
initData = argList;
argList = 0;
}
else if(!PyList_Check(argList))
{
PyErr_Format(PyExc_ValueError, STRCAST("initialize expects an argument list or Ice.InitializationData"));
return -1;
}
}
else if(argList && initData)
{
if(!PyList_Check(argList) || !PyObject_IsInstance(initData, initDataType))
{
PyErr_Format(PyExc_ValueError, STRCAST("initialize expects an argument list and Ice.InitializationData"));
return -1;
}
}
Ice::StringSeq seq;
if(argList && !listToStringSeq(argList, seq))
{
return -1;
}
//
// Use the with-args or the without-args version of initialize()?
//
bool hasArgs = argList != 0;
Ice::InitializationData data;
if(initData)
{
PyObjectHandle properties = PyObject_GetAttrString(initData, STRCAST("properties"));
PyObjectHandle logger = PyObject_GetAttrString(initData, STRCAST("logger"));
PyObjectHandle threadHook = PyObject_GetAttrString(initData, STRCAST("threadHook"));
PyObjectHandle batchRequestInterceptor = PyObject_GetAttrString(initData, STRCAST("batchRequestInterceptor"));
PyErr_Clear(); // PyObject_GetAttrString sets an error on failure.
if(properties.get() && properties.get() != Py_None)
{
//
// Get the properties implementation.
//
PyObjectHandle impl = PyObject_GetAttrString(properties.get(), STRCAST("_impl"));
assert(impl.get());
data.properties = getProperties(impl.get());
}
if(logger.get() && logger.get() != Py_None)
{
data.logger = new LoggerWrapper(logger.get());
}
if(threadHook.get() && threadHook.get() != Py_None)
{
data.threadHook = new ThreadHook(threadHook.get());
}
if(batchRequestInterceptor.get() && batchRequestInterceptor.get() != Py_None)
{
data.batchRequestInterceptor = new BatchRequestInterceptor(batchRequestInterceptor.get());
}
}
//
// We always supply our own implementation of ValueFactoryManager.
//
data.valueFactoryManager = new ValueFactoryManager;
try
{
if(argList)
{
data.properties = Ice::createProperties(seq, data.properties);
}
else if(!data.properties)
{
data.properties = Ice::createProperties();
}
}
catch(const Ice::Exception& ex)
{
setPythonException(ex);
return -1;
}
//
// Remaining command line options are passed to the communicator
// as an argument vector in case they contain plug-in properties.
//
int argc = static_cast<int>(seq.size());
char** argv = new char*[argc + 1];
int i = 0;
for(Ice::StringSeq::const_iterator s = seq.begin(); s != seq.end(); ++s, ++i)
{
argv[i] = strdup(s->c_str());
}
argv[argc] = 0;
data.compactIdResolver = new IdResolver;
Ice::CommunicatorPtr communicator;
try
{
AllowThreads allowThreads;
if(hasArgs)
{
communicator = Ice::initialize(argc, argv, data);
}
else
{
communicator = Ice::initialize(data);
}
}
catch(const Ice::Exception& ex)
{
for(i = 0; i < argc; ++i)
{
free(argv[i]);
}
delete[] argv;
setPythonException(ex);
return -1;
}
//
// Replace the contents of the given argument list with the filtered arguments.
//
if(argList)
{
PyList_SetSlice(argList, 0, PyList_Size(argList), 0); // Clear the list.
for(i = 0; i < argc; ++i)
{
PyObjectHandle str = Py_BuildValue(STRCAST("s"), argv[i]);
PyList_Append(argList, str.get());
}
}
for(i = 0; i < argc; ++i)
{
free(argv[i]);
}
delete[] argv;
self->communicator = new Ice::CommunicatorPtr(communicator);
CommunicatorMap::iterator p = _communicatorMap.find(communicator);
if(p != _communicatorMap.end())
{
_communicatorMap.erase(p);
}
_communicatorMap.insert(CommunicatorMap::value_type(communicator, reinterpret_cast<PyObject*>(self)));
return 0;
}
bool
NodeI::canRemoveServerDirectory(const string& name)
{
//
// Check if there's files which we didn't create.
//
Ice::StringSeq c = readDirectory(_serversDir + "/" + name);
set<string> contents(c.begin(), c.end());
contents.erase("dbs");
contents.erase("config");
contents.erase("distrib");
contents.erase("revision");
contents.erase("data");
Ice::StringSeq serviceDataDirs;
for(set<string>::const_iterator p = contents.begin(); p != contents.end(); ++p)
{
if(p->find("data_") != 0)
{
return false;
}
serviceDataDirs.push_back(*p);
}
if(!contents.empty())
{
return false;
}
c = readDirectory(_serversDir + "/" + name + "/config");
for(Ice::StringSeq::const_iterator p = c.begin() ; p != c.end(); ++p)
{
if(p->find("config") != 0)
{
return false;
}
}
if(IceUtilInternal::directoryExists(_serversDir + "/" + name + "/dbs"))
{
c = readDirectory(_serversDir + "/" + name + "/dbs");
for(Ice::StringSeq::const_iterator p = c.begin() ; p != c.end(); ++p)
{
try
{
Ice::StringSeq files = readDirectory(_serversDir + "/" + name + "/dbs/" + *p);
files.erase(remove(files.begin(), files.end(), "DB_CONFIG"), files.end());
files.erase(remove(files.begin(), files.end(), "__Freeze"), files.end());
if(!files.empty())
{
return false;
}
}
catch(const string&)
{
return false;
}
}
}
if(IceUtilInternal::directoryExists(_serversDir + "/" + name + "/data"))
{
if(!readDirectory(_serversDir + "/" + name + "/data").empty())
{
return false;
}
}
for(Ice::StringSeq::const_iterator p = serviceDataDirs.begin(); p != serviceDataDirs.end(); ++p)
{
try
{
if(!readDirectory(_serversDir + "/" + name + "/" + *p).empty())
{
return false;
}
}
catch(const string&)
{
return false;
}
}
return true;
}
vector<ServerCommandPtr>
NodeI::checkConsistencyNoSync(const Ice::StringSeq& servers)
{
vector<ServerCommandPtr> commands;
//
// Check if the servers directory doesn't contain more servers
// than the registry really knows.
//
Ice::StringSeq contents;
try
{
contents = readDirectory(_serversDir);
}
catch(const string& msg)
{
Ice::Error out(_traceLevels->logger);
out << "couldn't read directory `" << _serversDir << "':\n" << msg;
return commands;
}
vector<string> remove;
set_difference(contents.begin(), contents.end(), servers.begin(), servers.end(), back_inserter(remove));
//
// Remove the extra servers if possible.
//
try
{
vector<string>::iterator p = remove.begin();
while(p != remove.end())
{
ServerIPtr server = ServerIPtr::dynamicCast(_adapter->find(createServerIdentity(*p)));
if(server)
{
//
// If the server is loaded, we invoke on it to destroy it.
//
try
{
ServerCommandPtr command = server->destroy(0, "", 0, "Master", false);
if(command)
{
commands.push_back(command);
}
p = remove.erase(p);
continue;
}
catch(const Ice::LocalException& ex)
{
Ice::Error out(_traceLevels->logger);
out << "server `" << *p << "' destroy failed:\n" << ex;
}
catch(const string&)
{
assert(false);
}
}
try
{
if(canRemoveServerDirectory(*p))
{
//
// If the server directory can be removed and we
// either remove it or back it up before to remove it.
//
removeRecursive(_serversDir + "/" + *p);
p = remove.erase(p);
continue;
}
}
catch(const string& msg)
{
Ice::Warning out(_traceLevels->logger);
out << "removing server directory `" << _serversDir << "/" << *p << "' failed:\n" << msg;
}
*p = _serversDir + "/" + *p;
++p;
}
}
catch(const Ice::ObjectAdapterDeactivatedException&)
{
//
// Just return the server commands, we'll finish the
// consistency check next time the node is started.
//
return commands;
}
if(!remove.empty())
{
Ice::Warning out(_traceLevels->logger);
out << "server directories containing data not created or written by IceGrid were not removed:\n";
out << toString(remove);
}
return commands;
}
void
allTests(const Ice::CommunicatorPtr& comm)
{
IceGrid::RegistryPrx registry = IceGrid::RegistryPrx::checkedCast(
comm->stringToProxy(comm->getDefaultLocator()->ice_getIdentity().category + "/Registry"));
test(registry);
IceGrid::QueryPrx query = IceGrid::QueryPrx::checkedCast(
comm->stringToProxy(comm->getDefaultLocator()->ice_getIdentity().category + "/Query"));
test(query);
AdminSessionPrx session = registry->createAdminSession("foo", "bar");
session->ice_getConnection()->setACM(registry->getACMTimeout(), IceUtil::None, Ice::HeartbeatAlways);
AdminPrx admin = session->getAdmin();
test(admin);
cout << "testing server registration... " << flush;
Ice::StringSeq serverIds = admin->getAllServerIds();
test(find(serverIds.begin(), serverIds.end(), "Server1") != serverIds.end());
test(find(serverIds.begin(), serverIds.end(), "Server2") != serverIds.end());
test(find(serverIds.begin(), serverIds.end(), "IceBox1") != serverIds.end());
test(find(serverIds.begin(), serverIds.end(), "IceBox2") != serverIds.end());
test(find(serverIds.begin(), serverIds.end(), "SimpleServer") != serverIds.end());
test(find(serverIds.begin(), serverIds.end(), "SimpleIceBox") != serverIds.end());
cout << "ok" << endl;
cout << "testing adapter registration... " << flush;
Ice::StringSeq adapterIds = admin->getAllAdapterIds();
test(find(adapterIds.begin(), adapterIds.end(), "Server1.Server") != adapterIds.end());
test(find(adapterIds.begin(), adapterIds.end(), "Server2.Server") != adapterIds.end());
test(find(adapterIds.begin(), adapterIds.end(), "SimpleServer.Server") != adapterIds.end());
test(find(adapterIds.begin(), adapterIds.end(), "IceBox1.Service1.Service1") != adapterIds.end());
test(find(adapterIds.begin(), adapterIds.end(), "IceBox1Service2Adapter") != adapterIds.end());
test(find(adapterIds.begin(), adapterIds.end(), "IceBox2.Service1.Service1") != adapterIds.end());
test(find(adapterIds.begin(), adapterIds.end(), "IceBox2Service2Adapter") != adapterIds.end());
test(find(adapterIds.begin(), adapterIds.end(), "SimpleIceBox.SimpleService.SimpleService") != adapterIds.end());
test(find(adapterIds.begin(), adapterIds.end(), "ReplicatedAdapter") != adapterIds.end());
cout << "ok" << endl;
cout << "testing object registration... " << flush;
Ice::ObjectProxySeq objs = query->findAllObjectsByType("::Test");
test(find_if(objs.begin(), objs.end(), bind2nd(ProxyIdentityEqual(comm),"Server1")) != objs.end());
test(find_if(objs.begin(), objs.end(), bind2nd(ProxyIdentityEqual(comm),"Server2")) != objs.end());
test(find_if(objs.begin(), objs.end(), bind2nd(ProxyIdentityEqual(comm),"SimpleServer")) != objs.end());
test(find_if(objs.begin(), objs.end(), bind2nd(ProxyIdentityEqual(comm),"IceBox1-Service1")) != objs.end());
test(find_if(objs.begin(), objs.end(), bind2nd(ProxyIdentityEqual(comm),"IceBox1-Service2")) != objs.end());
test(find_if(objs.begin(), objs.end(), bind2nd(ProxyIdentityEqual(comm),"IceBox2-Service1")) != objs.end());
test(find_if(objs.begin(), objs.end(), bind2nd(ProxyIdentityEqual(comm),"IceBox2-Service2")) != objs.end());
test(find_if(objs.begin(), objs.end(), bind2nd(ProxyIdentityEqual(comm),"SimpleIceBox-SimpleService")) != objs.end());
test(find_if(objs.begin(), objs.end(), bind2nd(ProxyIdentityEqual(comm),"ReplicatedObject")) != objs.end());
{
test(identityToString(query->findObjectByType("::TestId1")->ice_getIdentity()) == "cat/name1");
test(identityToString(query->findObjectByType("::TestId2")->ice_getIdentity()) == "cat1/name1");
test(identityToString(query->findObjectByType("::TestId3")->ice_getIdentity()) == "cat1/name1-bis");
test(identityToString(query->findObjectByType("::TestId4")->ice_getIdentity()) == "c2\\/c2/n2\\/n2");
test(identityToString(query->findObjectByType("::TestId5")->ice_getIdentity()) == "n2\\/n2");
}
{
Ice::ObjectPrx obj = query->findObjectByType("::Test");
string id = identityToString(obj->ice_getIdentity());
test(id == "Server1" || id == "Server2" || id == "SimpleServer" ||
id == "IceBox1-Service1" || id == "IceBox1-Service2" ||
id == "IceBox2-Service1" || id == "IceBox2-Service2" ||
id == "SimpleIceBox-SimpleService" || "ReplicatedObject");
}
{
Ice::ObjectPrx obj = query->findObjectByTypeOnLeastLoadedNode("::Test", LoadSample5);
string id = identityToString(obj->ice_getIdentity());
test(id == "Server1" || id == "Server2" || id == "SimpleServer" ||
id == "IceBox1-Service1" || id == "IceBox1-Service2" ||
id == "IceBox2-Service1" || id == "IceBox2-Service2" ||
id == "SimpleIceBox-SimpleService" || "ReplicatedObject");
}
{
Ice::ObjectPrx obj = query->findObjectByType("::Foo");
test(!obj);
obj = query->findObjectByTypeOnLeastLoadedNode("::Foo", LoadSample15);
test(!obj);
}
Ice::Identity encoding10_oneway;
encoding10_oneway.name = "encoding10-oneway";
test(query->findObjectById(encoding10_oneway)->ice_getEncodingVersion() == Ice::Encoding_1_0);
test(query->findObjectById(encoding10_oneway)->ice_isOneway());
Ice::Identity encoding10_secure;
encoding10_secure.name = "encoding10-secure";
test(query->findObjectById(encoding10_secure)->ice_getEncodingVersion() == Ice::Encoding_1_0);
test(query->findObjectById(encoding10_secure)->ice_isSecure());
Ice::Identity oaoptions;
oaoptions.name = "oaoptions";
test(query->findObjectById(oaoptions)->ice_getEncodingVersion() == Ice::stringToEncodingVersion("1.2"));
test(query->findObjectById(oaoptions)->ice_isTwoway());
Ice::Identity comoptions;
comoptions.name = "communicatoroptions";
test(query->findObjectById(comoptions)->ice_getEncodingVersion() == Ice::stringToEncodingVersion("1.3"));
test(query->findObjectById(comoptions)->ice_isTwoway());
Ice::Identity options34;
options34.name = "34options";
test(query->findObjectById(options34)->ice_getEncodingVersion() == Ice::Encoding_1_0);
Ice::Identity simpleServer;
simpleServer.name = "SimpleServer";
test(query->findObjectById(simpleServer)->ice_getEncodingVersion() == Ice::Encoding_1_1);
Ice::Identity replicated15;
replicated15.name = "ReplicatedObject15";
test(query->findObjectById(replicated15)->ice_getEncodingVersion() == Ice::stringToEncodingVersion("1.5"));
Ice::Identity replicated14;
replicated14.name = "ReplicatedObject14";
test(query->findObjectById(replicated14)->ice_getEncodingVersion() == Ice::stringToEncodingVersion("1.4"));
Ice::LocatorPrx locator = comm->getDefaultLocator();
test(query->findObjectById(encoding10_oneway) == locator->findObjectById(encoding10_oneway));
test(query->findObjectById(encoding10_secure) == locator->findObjectById(encoding10_secure));
test(query->findObjectById(oaoptions) == locator->findObjectById(oaoptions));
test(query->findObjectById(comoptions) == locator->findObjectById(comoptions));
test(query->findObjectById(options34) == locator->findObjectById(options34));
test(query->findObjectById(simpleServer) == locator->findObjectById(simpleServer));
test(query->findObjectById(replicated15) == locator->findObjectById(replicated15));
test(query->findObjectById(replicated14) == locator->findObjectById(replicated14));
cout << "ok" << endl;
//
// Ensure that all server and service objects are reachable.
//
// The identity for the test object in deployed server or services
// is the name of the service or server. The object adapter name
// is Adapter prefixed with the name of the service or
// server. Ensure we can reach each object.
//
cout << "pinging server objects... " << flush;
TestIntfPrx obj;
obj = TestIntfPrx::checkedCast(comm->stringToProxy("*****@*****.**"));
obj = TestIntfPrx::checkedCast(comm->stringToProxy("*****@*****.**"));
obj = TestIntfPrx::checkedCast(comm->stringToProxy("*****@*****.**"));
obj = TestIntfPrx::checkedCast(comm->stringToProxy("[email protected]"));
obj = TestIntfPrx::checkedCast(comm->stringToProxy("IceBox1-Service2@IceBox1Service2Adapter"));
obj = TestIntfPrx::checkedCast(comm->stringToProxy("[email protected]"));
obj = TestIntfPrx::checkedCast(comm->stringToProxy("IceBox2-Service2@IceBox2Service2Adapter"));
obj = TestIntfPrx::checkedCast(
comm->stringToProxy("*****@*****.**"));
cout << "ok" << endl;
cout << "testing server configuration... " << flush;
obj = TestIntfPrx::checkedCast(comm->stringToProxy("*****@*****.**"));
test(obj->getProperty("Type") == "Server");
test(obj->getProperty("Name") == "Server1");
test(obj->getProperty("NameName") == "Server1Server1");
test(obj->getProperty("NameEscaped") == "${name}");
test(obj->getProperty("NameEscapeEscaped") == "$Server1");
test(obj->getProperty("NameEscapedEscapeEscaped") == "$${name}");
test(obj->getProperty("ManyEscape") == "$$$${name}");
test(obj->getProperty("TestServer1Identity") == "Server1");
test(obj->getProperty("LogFilePath") == "test-Server1.log");
test(obj->getProperty("LogFilePath-Server1") == "test.log");
test(obj->getProperty("PropertyWithSpaces") == " test ");
// \ is escaped in C++ string literals
test(obj->getProperty("WindowsPath") == "C:\\Program Files (x86)\\ZeroC\\");
test(obj->getProperty("UNCPath") == "\\\\server\\foo bar\\file");
test(obj->getProperty("PropertyWith=") == "foo=bar");
test(obj->getProperty("PropertyWithHash") == "foo#bar");
test(obj->getProperty("PropertyWithTab") == "foo\tbar");
test(obj->getProperty("PropertyWithEscapeSpace") == "foo\\ ");
test(obj->getProperty("PropertyWithProperty") == "Plugin.EntryPoint=foo:bar --Ice.Config=\\\\\\server\\foo bar\\file.cfg");
cout << "ok" << endl;
cout << "testing service configuration... " << flush;
obj = TestIntfPrx::checkedCast(comm->stringToProxy("[email protected]"));
test(obj->getProperty("Service1.Type") == "standard");
test(obj->getProperty("Service1.ServiceName") == "Service1");
test(obj->getProperty("TestService1Identity") == "IceBox1-Service1");
test(obj->getProperty("LogFilePath") == "test-Service1.log");
test(obj->getProperty("LogFilePath-Service1") == "test.log");
test(obj->getProperty("PropertyWithSpaces") == " test ");
// \ is escaped in C++ string literals
test(obj->getProperty("WindowsPath") == "C:\\Program Files (x86)\\ZeroC\\");
test(obj->getProperty("UNCPath") == "\\\\server\\foo bar\\file");
test(obj->getProperty("PropertyWith=") == "foo=bar");
test(obj->getProperty("PropertyWithHash") == "foo#bar");
test(obj->getProperty("PropertyWithTab") == "foo\tbar");
test(obj->getProperty("PropertyWithEscapeSpace") == "foo\\ ");
test(obj->getProperty("PropertyWithProperty") == "Plugin.EntryPoint=foo:bar --Ice.Config=\\\\\\server\\foo bar\\file.cfg");
obj = TestIntfPrx::checkedCast(comm->stringToProxy("IceBox2-Service2@IceBox2Service2Adapter"));
test(obj->getProperty("Service2.Type") == "nonstandard");
test(obj->getProperty("Service2.ServiceName") == "Service2");
test(obj->getProperty("Service2.DebugProperty") == "");
test(obj->getProperty("Service1.DebugProperty") == "");
cout << "ok" << endl;
cout << "testing server options... " << flush;
obj = TestIntfPrx::checkedCast(comm->stringToProxy("*****@*****.**"));
test(obj->getProperty("Test.Test") == "2");
test(obj->getProperty("Test.Test1") == "0");
cout << "ok" << endl;
cout << "testing variables... " << flush;
vector<TestIntfPrx> proxies;
obj = TestIntfPrx::checkedCast(comm->stringToProxy("*****@*****.**"));
proxies.push_back(obj);
obj = TestIntfPrx::checkedCast(comm->stringToProxy("[email protected]"));
proxies.push_back(obj);
obj = TestIntfPrx::checkedCast(comm->stringToProxy("*****@*****.**"));
proxies.push_back(obj);
obj = TestIntfPrx::checkedCast(
comm->stringToProxy("*****@*****.**"));
proxies.push_back(obj);
for(vector<TestIntfPrx>::const_iterator p = proxies.begin(); p != proxies.end(); ++p)
{
test((*p)->getProperty("AppVarProp") == "AppVar");
test((*p)->getProperty("NodeVarProp") == "NodeVar");
test((*p)->getProperty("RecursiveAppVarProp") == "Test");
test((*p)->getProperty("AppVarOverridedProp") == "OverridedInNode");
test((*p)->getProperty("AppVarDefinedInNodeProp") == "localnode");
test((*p)->getProperty("EscapedAppVarProp") == "${escaped}");
test((*p)->getProperty("RecursiveEscapedAppVarProp") == "${escaped}");
test((*p)->getProperty("Recursive2EscapedAppVarProp") == "${escaped}");
test((*p)->getProperty("RecursiveNodeVarProp") == "localnode");
test((*p)->getProperty("TestDirProp") != "NotThisValue");
}
cout << "ok" << endl;
cout << "testing parameters... " << flush;
obj = TestIntfPrx::checkedCast(comm->stringToProxy("*****@*****.**"));
test(obj->getProperty("Param1Prop") == "Param1");
test(obj->getProperty("Param2Prop") == "AppVar");
test(obj->getProperty("ParamEscapedProp") == "${escaped}");
test(obj->getProperty("ParamDoubleEscapedProp") == "$escapedvalue");
test(obj->getProperty("AppVarOverridedByParamProp") == "Overrided");
test(obj->getProperty("NodeVarOverridedByParamProp") == "Test");
test(obj->getProperty("DefaultParamProp") == "VALUE");
obj = TestIntfPrx::checkedCast(comm->stringToProxy("*****@*****.**"));
test(obj->getProperty("Param1Prop") == "Param12");
test(obj->getProperty("Param2Prop") == "OverridedInNode");
test(obj->getProperty("ParamEscapedProp") == "${escaped}");
test(obj->getProperty("ParamDoubleEscapedProp") == "$escapedvalue");
test(obj->getProperty("AppVarOverridedByParamProp") == "Overrided");
test(obj->getProperty("NodeVarOverridedByParamProp") == "Test");
test(obj->getProperty("DefaultParamProp") == "OTHERVALUE");
obj = TestIntfPrx::checkedCast(comm->stringToProxy("[email protected]"));
test(obj->getProperty("AppVarOverridedByParamProp") == "Test");
test(obj->getProperty("NodeVarOverridedByParamProp") == "Overrided");
obj = TestIntfPrx::checkedCast(comm->stringToProxy("IceBox1-Service2@IceBox1Service2Adapter"));
test(obj->getProperty("AppVarOverridedByParamProp") == "Test");
test(obj->getProperty("NodeVarOverridedByParamProp") == "Test");
obj = TestIntfPrx::checkedCast(comm->stringToProxy("[email protected]"));
test(obj->getProperty("AppVarOverridedByParamProp") == "Test");
test(obj->getProperty("NodeVarOverridedByParamProp") == "Overrided");
obj = TestIntfPrx::checkedCast(comm->stringToProxy("IceBox2-Service2@IceBox2Service2Adapter"));
test(obj->getProperty("AppVarOverridedByParamProp") == "Test");
test(obj->getProperty("NodeVarOverridedByParamProp") == "Test");
cout << "ok" << endl;
cout << "testing descriptions... " << flush;
//
// NOTE: We can't test the following since
// getApplicationDescriptor doesn't return the instantiated
// application descriptor...
//
// ApplicationDescriptor desc = admin->getApplicationDescriptor("test");
// test(desc.description == "APP AppVar");
// test(desc.nodes["localnode"].description == "NODE NodeVar");
// test(desc.replicaGroups[0].description == "REPLICA GROUP AppVar");
// test(desc.nodes["localnode"].servers.size() == 2);
// const int idx = desc.nodes["localnode"].servers[0]->id == "SimpleServer" ? 0 : 1;
ServerInfo info = admin->getServerInfo("SimpleServer");
test(info.descriptor->id == "SimpleServer");
test(info.descriptor->description == "SERVER NodeVar");
test(info.descriptor->adapters[0].description == "ADAPTER NodeVar");
test(info.descriptor->dbEnvs[0].description == "DBENV NodeVar");
cout << "ok" << endl;
cout << "testing property sets..." << flush;
obj = TestIntfPrx::checkedCast(comm->stringToProxy("*****@*****.**"));
test(obj->getProperty("AppProperty") == "AppVar");
test(obj->getProperty("AppProperty2") == "OverrideMe");
test(obj->getProperty("AppProperty21") == "Override");
test(obj->getProperty("NodeProperty") == "NodeVar");
obj = TestIntfPrx::checkedCast(comm->stringToProxy("*****@*****.**"));
test(obj->getProperty("AppProperty") == "AppVar");
test(obj->getProperty("AppProperty2") == "OverrideMe");
test(obj->getProperty("AppProperty21") == "Override");
test(obj->getProperty("NodeProperty") == "NodeVar");
test(obj->getProperty("ServerInstanceProperty") == "Server2");
obj = TestIntfPrx::checkedCast(comm->stringToProxy("[email protected]"));
test(obj->getProperty("AppProperty") == ""); // IceBox server properties aren't inherited for IceBox1
test(obj->getProperty("AppProperty2") == "");
test(obj->getProperty("AppProperty21") == "");
test(obj->getProperty("NodeProperty") == "");
obj = TestIntfPrx::checkedCast(comm->stringToProxy("[email protected]"));
test(obj->getProperty("AppProperty") == "AppVar");
test(obj->getProperty("AppProperty2") == "OverrideMe");
test(obj->getProperty("AppProperty21") == "Override");
test(obj->getProperty("NodeProperty") == "NodeVar");
test(obj->getProperty("IceBoxInstanceProperty") == "IceBox2");
obj = TestIntfPrx::checkedCast(comm->stringToProxy("IceBox2-Service2@IceBox2Service2Adapter"));
test(obj->getProperty("AppProperty") == "AppVar");
test(obj->getProperty("AppProperty2") == "OverrideMe");
test(obj->getProperty("AppProperty21") == "Override");
test(obj->getProperty("NodeProperty") == "NodeVar");
test(obj->getProperty("IceBoxInstanceProperty") == "IceBox2");
test(obj->getProperty("ServiceInstanceProperty") == "Service2");
obj = TestIntfPrx::checkedCast(comm->stringToProxy("*****@*****.**"));
test(obj->getProperty("AppProperty") == "AppVar");
test(obj->getProperty("AppProperty2") == "OverrideMe");
test(obj->getProperty("AppProperty21") == "Override");
test(obj->getProperty("NodeProperty") == "NodeVar");
obj = TestIntfPrx::checkedCast(comm->stringToProxy("[email protected]"));
test(obj->getProperty("ServerInstanceServiceProperty") == "service1");
obj = TestIntfPrx::checkedCast(comm->stringToProxy("[email protected]"));
test(obj->getProperty("ServerInstanceServiceProperty") == "service4");
obj = TestIntfPrx::checkedCast(comm->stringToProxy("[email protected]"));
test(obj->getProperty("IceBoxInstanceProperty") == "overriden");
cout << "ok" << endl;
cout << "testing validation... " << flush;
TemplateDescriptor templ;
templ.parameters.push_back("name");
templ.parameters.push_back("nam3");
templ.parameters.push_back("nam2");
templ.parameters.push_back("nam3");
templ.descriptor = new ServerDescriptor();
ServerDescriptorPtr server = ServerDescriptorPtr::dynamicCast(templ.descriptor);
server->id = "test";
server->exe = "${test.dir}/server";
server->applicationDistrib = false;
server->allocatable = false;
ApplicationDescriptor desc;
desc.name = "App";
desc.serverTemplates["ServerTemplate"] = templ;
try
{
admin->addApplication(desc);
test(false);
}
catch(const DeploymentException& ex)
{
test(ex.reason.find("duplicate parameters") != string::npos);
}
catch(const Ice::Exception& ex)
{
cerr << ex << endl;
test(false);
}
cout << "ok" << endl;
logTests(comm, session);
session->destroy();
}