ClassAdWrapper *parseOld(object input)
{
ClassAdWrapper * wrapper = new ClassAdWrapper();
object input_list;
extract<std::string> input_extract(input);
if (input_extract.check())
{
input_list = input.attr("splitlines")();
}
else
{
input_list = input.attr("readlines")();
}
unsigned input_len = py_len(input_list);
for (unsigned idx=0; idx<input_len; idx++)
{
object line = input_list[idx].attr("strip")();
if (line.attr("startswith")("#"))
{
continue;
}
std::string line_str = extract<std::string>(line);
if (!wrapper->Insert(line_str))
{
PyErr_SetString(PyExc_SyntaxError, line_str.c_str());
throw_error_already_set();
}
}
return wrapper;
}
void send_alive(boost::python::object ad_obj=boost::python::object(), boost::python::object pid_obj=boost::python::object(), boost::python::object timeout_obj=boost::python::object())
{
std::string addr;
if (ad_obj.ptr() == Py_None)
{
char *inherit_var = getenv("CONDOR_INHERIT");
if (!inherit_var) {
THROW_EX(RuntimeError, "No location specified and $CONDOR_INHERIT not in Unix environment.");
}
std::string inherit(inherit_var);
boost::python::object inherit_obj(inherit);
boost::python::object inherit_split = inherit_obj.attr("split")();
if (py_len(inherit_split) < 2) {
THROW_EX(RuntimeError, "$CONDOR_INHERIT Unix environment variable malformed.");
}
addr = boost::python::extract<std::string>(inherit_split[1]);
}
else
{
const ClassAdWrapper ad = boost::python::extract<ClassAdWrapper>(ad_obj);
if (!ad.EvaluateAttrString(ATTR_MY_ADDRESS, addr))
{
THROW_EX(ValueError, "Address not available in location ClassAd.");
}
}
int pid = getpid();
if (pid_obj.ptr() != Py_None)
{
pid = boost::python::extract<int>(pid_obj);
}
int timeout;
if (timeout_obj.ptr() == Py_None)
{
timeout = param_integer("NOT_RESPONDING_TIMEOUT");
}
else
{
timeout = boost::python::extract<int>(timeout_obj);
}
if (timeout < 1) {
timeout = 1;
}
classy_counted_ptr<Daemon> daemon = new Daemon(DT_ANY, addr.c_str());
classy_counted_ptr<ChildAliveMsg> msg = new ChildAliveMsg(pid, timeout, 0, 0, true);
{
condor::ModuleLock ml;
daemon->sendBlockingMsg(msg.get());
}
if (msg->deliveryStatus() != DCMsg::DELIVERY_SUCCEEDED)
{
THROW_EX(RuntimeError, "Failed to deliver keepalive message.");
}
}
Claim(boost::python::object ad_obj)
{
ClassAdWrapper ad = boost::python::extract<ClassAdWrapper>(ad_obj);
// TODO: Handle child d-slot claims, claim lists, etc
// Note this may leave 'ad' blank.
if (!ad.EvaluateAttrString(ATTR_CLAIM_ID, m_claim))
{
ad.EvaluateAttrString(ATTR_CAPABILITY, m_claim);
}
if (!ad.EvaluateAttrString(ATTR_MY_ADDRESS, m_addr))
{
THROW_EX(ValueError, "No contact string in ClassAd");
}
}
void send_command(const ClassAdWrapper & ad, DaemonCommands dc, const std::string &target="")
{
std::string addr;
if (!ad.EvaluateAttrString(ATTR_MY_ADDRESS, addr))
{
PyErr_SetString(PyExc_ValueError, "Address not available in location ClassAd.");
throw_error_already_set();
}
std::string ad_type_str;
if (!ad.EvaluateAttrString(ATTR_MY_TYPE, ad_type_str))
{
PyErr_SetString(PyExc_ValueError, "Daemon type not available in location ClassAd.");
throw_error_already_set();
}
int ad_type = AdTypeFromString(ad_type_str.c_str());
if (ad_type == NO_AD)
{
printf("ad type %s.\n", ad_type_str.c_str());
PyErr_SetString(PyExc_ValueError, "Unknown ad type.");
throw_error_already_set();
}
daemon_t d_type;
switch (ad_type) {
case MASTER_AD:
d_type = DT_MASTER;
break;
case STARTD_AD:
d_type = DT_STARTD;
break;
case SCHEDD_AD:
d_type = DT_SCHEDD;
break;
case NEGOTIATOR_AD:
d_type = DT_NEGOTIATOR;
break;
case COLLECTOR_AD:
d_type = DT_COLLECTOR;
break;
default:
d_type = DT_NONE;
PyErr_SetString(PyExc_ValueError, "Unknown daemon type.");
throw_error_already_set();
}
ClassAd ad_copy;
ad_copy.CopyFrom(ad);
Daemon d(&ad_copy, d_type, NULL);
bool result;
{
condor::ModuleLock ml;
result = !d.locate();
}
if (result)
{
PyErr_SetString(PyExc_RuntimeError, "Unable to locate daemon.");
throw_error_already_set();
}
ReliSock sock;
{
condor::ModuleLock ml;
result = !sock.connect(d.addr());
}
if (result)
{
PyErr_SetString(PyExc_RuntimeError, "Unable to connect to the remote daemon");
throw_error_already_set();
}
{
condor::ModuleLock ml;
result = !d.startCommand(dc, &sock, 0, NULL);
}
if (result)
{
PyErr_SetString(PyExc_RuntimeError, "Failed to start command.");
throw_error_already_set();
}
if (target.size())
{
std::string target_to_send = target;
if (!sock.code(target_to_send))
{
PyErr_SetString(PyExc_RuntimeError, "Failed to send target.");
throw_error_already_set();
}
if (!sock.end_of_message())
{
PyErr_SetString(PyExc_RuntimeError, "Failed to send end-of-message.");
throw_error_already_set();
}
}
sock.close();
}
static
boost::python::tuple
getinitargs(const ClassAdWrapper& ad)
{
return boost::python::make_tuple(ad.toString());
}
void send_command(const ClassAdWrapper & ad, DaemonCommands dc, const std::string &target="")
{
std::string addr;
if (!ad.EvaluateAttrString(ATTR_MY_ADDRESS, addr))
{
PyErr_SetString(PyExc_ValueError, "Address not available in location ClassAd.");
throw_error_already_set();
}
std::string ad_type_str;
if (!ad.EvaluateAttrString(ATTR_MY_TYPE, ad_type_str))
{
PyErr_SetString(PyExc_ValueError, "Daemon type not available in location ClassAd.");
throw_error_already_set();
}
int ad_type = AdTypeFromString(ad_type_str.c_str());
if (ad_type == NO_AD)
{
PyErr_SetString(PyExc_ValueError, "Unknown ad type.");
throw_error_already_set();
}
daemon_t d_type;
switch (ad_type) {
case MASTER_AD: d_type = DT_MASTER; break;
case STARTD_AD: d_type = DT_STARTD; break;
case SCHEDD_AD: d_type = DT_SCHEDD; break;
case NEGOTIATOR_AD: d_type = DT_NEGOTIATOR; break;
case COLLECTOR_AD: d_type = DT_COLLECTOR; break;
default:
PyErr_SetString(PyExc_ValueError, "Unknown daemon type.");
throw_error_already_set();
}
ClassAd ad_copy; ad_copy.CopyFrom(ad);
Daemon d(&ad_copy, d_type, NULL);
if (!d.locate())
{
PyErr_SetString(PyExc_RuntimeError, "Unable to locate daemon.");
throw_error_already_set();
}
ReliSock sock;
if (!sock.connect(d.addr()))
{
PyErr_SetString(PyExc_RuntimeError, "Unable to connect to the remote daemon");
throw_error_already_set();
}
if (!d.startCommand(dc, &sock, 0, NULL))
{
PyErr_SetString(PyExc_RuntimeError, "Failed to start command.");
throw_error_already_set();
}
if (target.size())
{
std::vector<unsigned char> target_cstr; target_cstr.reserve(target.size()+1);
memcpy(&target_cstr[0], target.c_str(), target.size()+1);
if (!sock.code(&target_cstr[0]))
{
PyErr_SetString(PyExc_RuntimeError, "Failed to send target.");
throw_error_already_set();
}
if (!sock.end_of_message())
{
PyErr_SetString(PyExc_RuntimeError, "Failed to send end-of-message.");
throw_error_already_set();
}
}
sock.close();
}
