int
CCBListener::ReverseConnected(Stream *stream)
{
Sock *sock = (Sock *)stream;
ClassAd *msg_ad = (ClassAd *)daemonCore->GetDataPtr();
ASSERT( msg_ad );
if( sock ) {
daemonCore->Cancel_Socket( sock );
}
if( !sock || !sock->is_connected() ) {
ReportReverseConnectResult(msg_ad,false,"failed to connect");
}
else {
// The reverse-connect protocol is designed to look like a
// raw cedar command, in case the thing we are connecting
// to is a cedar command socket.
sock->encode();
int cmd = CCB_REVERSE_CONNECT;
if( !sock->put(cmd) ||
!msg_ad->put( *sock ) ||
!sock->end_of_message() )
{
ReportReverseConnectResult(msg_ad,false,"failure writing reverse connect command");
}
else {
((ReliSock*)sock)->isClient(false);
daemonCore->HandleReqAsync(sock);
sock = NULL; // daemonCore took ownership of sock
ReportReverseConnectResult(msg_ad,true);
}
}
delete msg_ad;
if( sock ) {
delete sock;
}
decRefCount(); // we incremented ref count when setting up callback
return KEEP_STREAM;
}
int main( int argc, char *argv[] )
{
const char *filename=0;
char *pool=0;
int command=-1;
int i;
bool use_tcp = false;
bool with_ack = false;
bool allow_multiple = false;
param_functions *p_funcs = NULL;
myDistro->Init( argc, argv );
config();
p_funcs = get_param_functions();
for( i=1; i<argc; i++ ) {
if(!strcmp(argv[i],"-help")) {
usage(argv[0]);
exit(0);
} else if(!strcmp(argv[i],"-pool")) {
i++;
if(!argv[i]) {
fprintf(stderr,"-pool requires an argument.\n\n");
usage(argv[0]);
exit(1);
}
pool = argv[i];
} else if(!strncmp(argv[i],"-tcp",strlen(argv[i]))) {
use_tcp = true;
} else if(!strncmp(argv[i],"-multiple",strlen(argv[i]))) {
// We don't set allow_multiple=true by default, because
// existing users (e.g. glideinWMS) have stray blank lines
// in the input file.
allow_multiple = true;
} else if(!strcmp(argv[i],"-version")) {
version();
exit(0);
} else if(!strcmp(argv[i],"-debug")) {
// dprintf to console
Termlog = 1;
p_funcs = get_param_functions();
dprintf_config ("TOOL", p_funcs);
} else if(argv[i][0]!='-' || !strcmp(argv[i],"-")) {
if(command==-1) {
command = getCollectorCommandNum(argv[i]);
if(command==-1) {
fprintf(stderr,"Unknown command name %s\n\n",argv[i]);
usage(argv[0]);
exit(1);
}
} else if(!filename) {
filename = argv[i];
} else {
fprintf(stderr,"Extra argument: %s\n\n",argv[i]);
usage(argv[0]);
exit(1);
}
} else {
fprintf(stderr,"Unknown argument: %s\n\n",argv[i]);
usage(argv[0]);
exit(1);
}
}
FILE *file;
ClassAdList ads;
Daemon *collector;
Sock *sock;
switch( command ) {
case UPDATE_STARTD_AD_WITH_ACK:
with_ack = true;
break;
}
if( with_ack ) {
use_tcp = true;
}
if(!filename || !strcmp(filename,"-")) {
file = stdin;
filename = "(stdin)";
} else {
file = safe_fopen_wrapper_follow(filename,"r");
}
if(!file) {
fprintf(stderr,"couldn't open %s: %s\n",filename,strerror(errno));
return 1;
}
while(!feof(file)) {
int eof=0,error=0,empty=0;
char const *delim = "\n";
if( !allow_multiple ) {
delim = "***";
}
ClassAd *ad = new ClassAd(file,const_cast<char *>(delim),eof,error,empty);
if(error) {
fprintf(stderr,"couldn't parse ClassAd in %s\n",filename);
delete ad;
return 1;
}
if( empty ) {
delete ad;
break;
}
if( !allow_multiple && ads.Length() > 0 ) {
fprintf(stderr,"ERROR: failed to parse '%s' as a ClassAd attribute\n",delim);
delete ad;
return 1;
}
ads.Insert(ad);
}
if(ads.Length() == 0) {
fprintf(stderr,"%s is empty\n",filename);
return 1;
}
CollectorList * collectors;
if ( pool ) {
collector = new Daemon( DT_COLLECTOR, pool, 0 );
collectors = new CollectorList();
collectors->append (collector);
} else {
collectors = CollectorList::create();
}
bool had_error = false;
collectors->rewind();
while (collectors->next(collector)) {
dprintf(D_FULLDEBUG,"locating collector %s...\n", collector->name());
if(!collector->locate()) {
fprintf(stderr,"couldn't locate collector: %s\n",collector->error());
had_error = true;
continue;
}
dprintf(D_FULLDEBUG,"collector is %s located at %s\n",
collector->hostname(),collector->addr());
sock = NULL;
ClassAd *ad;
int success_count = 0;
int failure_count = 0;
ads.Rewind();
while( (ad=ads.Next()) ) {
// If there's no "MyAddress", generate one..
if( !ad->Lookup( ATTR_MY_ADDRESS ) ) {
MyString tmp;
tmp.formatstr( "<%s:0>", my_ip_string() );
ad->Assign( ATTR_MY_ADDRESS, tmp.Value() );
}
if ( use_tcp ) {
if( !sock ) {
sock = collector->startCommand(command,Stream::reli_sock,20);
}
else {
// Use existing connection.
sock->encode();
sock->put(command);
}
} else {
// We must open a new UDP socket each time.
delete sock;
sock = collector->startCommand(command,Stream::safe_sock,20);
}
int result = 0;
if ( sock ) {
result += ad->put( *sock );
result += sock->end_of_message();
}
if ( result != 2 ) {
fprintf(stderr,"failed to send classad to %s\n",collector->addr());
had_error = true;
failure_count++;
delete sock;
sock = NULL;
continue;
}
if( with_ack ) {
sock->decode();
int ok = 0;
if( !sock->get(ok) || !sock->end_of_message() ) {
fprintf(stderr,"failed to get ack from %s\n",collector->addr());
had_error = true;
failure_count++;
delete sock;
sock = NULL;
continue;
}
// ack protocol does not allow for multiple updates,
// so close the socket now
delete sock;
sock = NULL;
}
success_count++;
}
if( sock ) {
CondorVersionInfo const *ver = sock->get_peer_version();
if( !ver || ver->built_since_version(7,7,3) ) {
// graceful hangup so the collector knows we are done
sock->encode();
command = DC_NOP;
sock->put(command);
sock->end_of_message();
}
delete sock;
sock = NULL;
}
printf("Sent %d of %d ad%s to %s.\n",
success_count,
success_count + failure_count,
success_count+failure_count == 1 ? "" : "s",
collector->name());
}
delete collectors;
return (had_error)?1:0;
}
int
main(int argc, char* argv[])
{
bool LongFlag=false;
bool HierFlag=true;
int ResetUsage=0;
int DeleteUser=0;
int SetFactor=0;
int SetPrio=0;
int SetAccum=0;
int SetBegin=0;
int SetLast=0;
bool ResetAll=false;
int GetResList=0;
std::string pool;
bool GroupRollup = false;
myDistro->Init( argc, argv );
config();
MinLastUsageTime=time(0)-60*60*24; // Default to show only users active in the last day
for (int i=1; i<argc; i++) {
if (IsArg(argv[i],"setprio")) {
if (i+2>=argc) usage(argv[0]);
SetPrio=i;
i+=2;
}
else if (IsArg(argv[i],"setfactor")) {
if (i+2>=argc) usage(argv[0]);
SetFactor=i;
i+=2;
}
else if (IsArg(argv[i],"setbegin")) {
if (i+2>=argc) usage(argv[0]);
SetBegin=i;
i+=2;
}
else if (IsArg(argv[i],"setaccum")) {
if (i+2>=argc) usage(argv[0]);
SetAccum=i;
i+=2;
}
else if (IsArg(argv[i],"setlast")) {
if (i+2>=argc) usage(argv[0]);
SetLast=i;
i+=2;
}
else if (IsArg(argv[i],"resetusage")) {
if (i+1>=argc) usage(argv[0]);
ResetUsage=i;
i+=1;
}
else if (IsArg(argv[i],"delete",3)) {
if (i+1>=argc) usage(argv[0]);
DeleteUser=i;
i+=1;
}
else if (IsArg(argv[i],"resetall")) {
ResetAll=true;
}
else if (IsArg(argv[i],"long",1)) {
LongFlag=true;
}
else if (IsArg(argv[i],"hierarchical",2) || IsArg(argv[i],"heir")) {
HierFlag=true;
DashHier=true;
}
else if (IsArg(argv[i],"flat",2)) {
HierFlag=false;
DashHier=true;
}
else if (IsArg(argv[i],"grouprollup")) {
GroupRollup=true;
}
else if (IsArg(argv[i],"grouporder")) {
GroupOrder=true;
HierFlag = false;
DashHier = true;
}
else if (IsArg(argv[i],"quotas",1)) {
DetailFlag |= DetailQuotas;
DashQuota = true;
}
else if (IsArg(argv[i],"surplus")) {
DetailFlag |= DetailSurplus;
DashQuota = true;
}
else if (IsArg(argv[i],"sortkey",2)) {
DetailFlag |= DetailSortKey;
DashSortKey = true;
}
else if (IsArg(argv[i],"all")) {
DetailFlag |= DetailAll;
DashAll = true;
}
else if (IsArg(argv[i],"most",2)) {
DetailFlag |= DetailMost;
#ifdef DEBUG
DetailFlag |= DetailGroup;
#endif
DashAll = true;
}
else if (IsArg(argv[i],"groupid")) {
DetailFlag |= DetailGroup;
}
else if (IsArg(argv[i],"order")) {
DetailFlag |= DetailOrder;
}
else if (IsArg(argv[i],"activefrom")) {
if (argc-i<=3) usage(argv[0]);
int month=atoi(argv[i+1]);
int day=atoi(argv[i+2]);
int year=atoi(argv[i+3]);
MinLastUsageTime=CalcTime(month,day,year);
// printf("Date translation: %d/%d/%d = %d\n",month,day,year,FromDate);
i+=3;
}
else if (IsArg(argv[i],"allusers")) {
MinLastUsageTime=-1;
}
else if (IsArg(argv[i],"usage",2)) {
DetailFlag |= DetailUsage | DetailUseTime1 | DetailUseTime2;
}
else if (IsArg(argv[i],"priority",4)) {
DetailFlag |= DetailPrios;
}
else if (IsArg(argv[i],"getreslist",6)) {
if (argc-i<=1) usage(argv[0]);
GetResList=i;
i+=1;
}
else if (IsArg(argv[i],"pool",1)) {
if (argc-i<=1) usage(argv[0]);
pool = argv[i+1];
i++;
}
else {
usage(argv[0]);
}
}
//----------------------------------------------------------
// Get info on our negotiator
Daemon negotiator(DT_NEGOTIATOR, NULL, (pool != "") ? pool.c_str() : NULL);
if (!negotiator.locate()) {
fprintf(stderr, "%s: Can't locate negotiator in %s\n",
argv[0], (pool != "") ? pool.c_str() : "local pool");
exit(1);
}
if (SetPrio) { // set priority
char* tmp;
if( ! (tmp = strchr(argv[SetPrio+1], '@')) ) {
fprintf( stderr,
"%s: You must specify the full name of the submittor you wish\n",
argv[0] );
fprintf( stderr, "\tto update the priority of (%s or %s)\n",
"*****@*****.**", "*****@*****.**" );
exit(1);
}
float Priority=atof(argv[SetPrio+2]);
// send request
Sock* sock;
if( !(sock = negotiator.startCommand(SET_PRIORITY,
Stream::reli_sock, 0) ) ||
!sock->put(argv[SetPrio+1]) ||
!sock->put(Priority) ||
!sock->end_of_message()) {
fprintf( stderr, "failed to send SET_PRIORITY command to negotiator\n" );
exit(1);
}
sock->close();
delete sock;
printf("The priority of %s was set to %f\n",argv[SetPrio+1],Priority);
}
else if (SetFactor) { // set priority
char* tmp;
if( ! (tmp = strchr(argv[SetFactor+1], '@')) ) {
fprintf( stderr,
"%s: You must specify the full name of the submittor you wish\n",
argv[0] );
fprintf( stderr, "\tto update the priority of (%s or %s)\n",
"*****@*****.**", "*****@*****.**" );
exit(1);
}
float Factor=atof(argv[SetFactor+2]);
if (Factor<1) {
fprintf( stderr, "Priority factors must be greater than or equal to "
"1.\n");
exit(1);
}
// send request
Sock* sock;
if( !(sock = negotiator.startCommand(SET_PRIORITYFACTOR,
Stream::reli_sock, 0) ) ||
!sock->put(argv[SetFactor+1]) ||
!sock->put(Factor) ||
!sock->end_of_message()) {
fprintf( stderr, "failed to send SET_PRIORITYFACTOR command to negotiator\n" );
exit(1);
}
sock->close();
delete sock;
printf("The priority factor of %s was set to %f\n",argv[SetFactor+1],Factor);
}
else if (SetAccum) { // set accumulated usage
char* tmp;
if( ! (tmp = strchr(argv[SetAccum+1], '@')) ) {
fprintf( stderr,
"%s: You must specify the full name of the submittor you wish\n",
argv[0] );
fprintf( stderr, "\tto update the Accumulated usage of (%s or %s)\n",
"*****@*****.**", "*****@*****.**" );
exit(1);
}
float accumUsage=atof(argv[SetAccum+2]);
if (accumUsage<0.0) {
fprintf( stderr, "Usage must be greater than 0 seconds\n");
exit(1);
}
// send request
Sock* sock;
if( !(sock = negotiator.startCommand(SET_ACCUMUSAGE,
Stream::reli_sock, 0) ) ||
!sock->put(argv[SetAccum+1]) ||
!sock->put(accumUsage) ||
!sock->end_of_message()) {
fprintf( stderr, "failed to send SET_ACCUMUSAGE command to negotiator\n" );
exit(1);
}
sock->close();
delete sock;
printf("The Accumulated Usage of %s was set to %f\n",argv[SetAccum+1],accumUsage);
}
else if (SetBegin) { // set begin usage time
char* tmp;
if( ! (tmp = strchr(argv[SetBegin+1], '@')) ) {
fprintf( stderr,
"%s: You must specify the full name of the submittor you wish\n",
argv[0] );
fprintf( stderr, "\tto update the begin usage time of (%s or %s)\n",
"*****@*****.**", "*****@*****.**" );
exit(1);
}
int beginTime=atoi(argv[SetBegin+2]);
if (beginTime<0) {
fprintf( stderr, "Time must be greater than 0 seconds\n");
exit(1);
}
// send request
Sock* sock;
if( !(sock = negotiator.startCommand(SET_BEGINTIME,
Stream::reli_sock, 0) ) ||
!sock->put(argv[SetBegin+1]) ||
!sock->put(beginTime) ||
!sock->end_of_message()) {
fprintf( stderr, "failed to send SET_BEGINTIME command to negotiator\n" );
exit(1);
}
sock->close();
delete sock;
printf("The Begin Usage Time of %s was set to %d\n",
argv[SetBegin+1],beginTime);
}
else if (SetLast) { // set last usage time
char* tmp;
if( ! (tmp = strchr(argv[SetLast+1], '@')) ) {
fprintf( stderr,
"%s: You must specify the full name of the submittor you wish\n",
argv[0] );
fprintf( stderr, "\tto update the last usage time of (%s or %s)\n",
"*****@*****.**", "*****@*****.**" );
exit(1);
}
int lastTime=atoi(argv[SetLast+2]);
if (lastTime<0) {
fprintf( stderr, "Time must be greater than 0 seconds\n");
exit(1);
}
// send request
Sock* sock;
if( !(sock = negotiator.startCommand(SET_LASTTIME,
Stream::reli_sock, 0) ) ||
!sock->put(argv[SetLast+1]) ||
!sock->put(lastTime) ||
!sock->end_of_message()) {
fprintf( stderr, "failed to send SET_LASTTIME command to negotiator\n" );
exit(1);
}
sock->close();
delete sock;
printf("The Last Usage Time of %s was set to %d\n",
argv[SetLast+1],lastTime);
}
else if (ResetUsage) { // set priority
char* tmp;
if( ! (tmp = strchr(argv[ResetUsage+1], '@')) ) {
fprintf( stderr,
"%s: You must specify the full name of the submittor you wish\n",
argv[0] );
fprintf( stderr, "\tto update the priority of (%s or %s)\n",
"*****@*****.**", "*****@*****.**" );
exit(1);
}
// send request
Sock* sock;
if( !(sock = negotiator.startCommand(RESET_USAGE,
Stream::reli_sock, 0) ) ||
!sock->put(argv[ResetUsage+1]) ||
!sock->end_of_message()) {
fprintf( stderr, "failed to send RESET_USAGE command to negotiator\n" );
exit(1);
}
sock->close();
delete sock;
printf("The accumulated usage of %s was reset\n",argv[ResetUsage+1]);
}
else if (DeleteUser) { // remove a user record from the accountant
char* tmp;
if( ! (tmp = strchr(argv[DeleteUser+1], '@')) ) {
fprintf( stderr,
"%s: You must specify the full name of the record you wish\n",
argv[0] );
fprintf( stderr, "\tto delete (%s or %s)\n",
"*****@*****.**", "*****@*****.**" );
exit(1);
}
// send request
Sock* sock;
if( !(sock = negotiator.startCommand(DELETE_USER,
Stream::reli_sock, 0) ) ||
!sock->put(argv[DeleteUser+1]) ||
!sock->end_of_message()) {
fprintf( stderr, "failed to send DELETE_USER command to negotiator\n" );
exit(1);
}
sock->close();
delete sock;
printf("The accountant record named %s was deleted\n",argv[DeleteUser+1]);
}
else if (ResetAll) {
// send request
if( ! negotiator.sendCommand(RESET_ALL_USAGE, Stream::reli_sock, 0) ) {
fprintf( stderr,
"failed to send RESET_ALL_USAGE command to negotiator\n" );
exit(1);
}
printf("The accumulated usage was reset for all users\n");
}
else if (GetResList) { // get resource list
char* tmp;
if( ! (tmp = strchr(argv[GetResList+1], '@')) ) {
fprintf( stderr,
"%s: You must specify the full name of the submittor you wish\n",
argv[0] );
fprintf( stderr, "\tto update the priority of (%s or %s)\n",
"*****@*****.**", "*****@*****.**" );
exit(1);
}
// send request
Sock* sock;
if( !(sock = negotiator.startCommand(GET_RESLIST,
Stream::reli_sock, 0) ) ||
!sock->put(argv[GetResList+1]) ||
!sock->end_of_message()) {
fprintf( stderr, "failed to send GET_RESLIST command to negotiator\n" );
exit(1);
}
// get reply
sock->decode();
AttrList* ad=new AttrList();
if (!ad->initAttrListFromStream(*sock) ||
!sock->end_of_message()) {
fprintf( stderr, "failed to get classad from negotiator\n" );
exit(1);
}
sock->close();
delete sock;
if (LongFlag) ad->fPrint(stdout);
else PrintResList(ad);
}
else { // list priorities
Sock* sock;
if (!(sock = negotiator.startCommand((GroupRollup) ? GET_PRIORITY_ROLLUP : GET_PRIORITY, Stream::reli_sock, 0)) ||
!sock->end_of_message()) {
fprintf(stderr, "failed to send %s command to negotiator\n", (GroupRollup) ? "GET_PRIORITY_ROLLUP" : "GET_PRIORITY");
exit(1);
}
// get reply
sock->decode();
AttrList* ad=new AttrList();
if (!ad->initAttrListFromStream(*sock) ||
!sock->end_of_message()) {
fprintf( stderr, "failed to get classad from negotiator\n" );
exit(1);
}
sock->close();
delete sock;
// if no details specified, show priorities
if ( ! DetailFlag) {
DetailFlag = DetailDefault;
#ifdef DEBUG
DetailFlag |= DetailGroup;
#endif
}
// if showing only prio, don't bother showing groups
if ( ! (DetailFlag & ~DetailPrios) && GroupPrioIsMeaningless) {
if ( ! DashHier ) HierFlag = false;
HideGroups = !HierFlag;
}
if (LongFlag) ad->fPrint(stdout);
else ProcessInfo(ad,GroupRollup,HierFlag);
}
exit(0);
return 0;
}
