void DestoryTreeNode(TreeNode* pTreeNode, FreeProc pFreeProc, bool bIncludeChildren) { if(pTreeNode == NULL) { return; } if(!bIncludeChildren) { DestroyProc(pTreeNode, pFreeProc); } else { pTreeNode->PostOrderEnum(DestroyProc, pFreeProc); } }
afx_msg void CServerView::OnEscape() { // always try to kill the one shot tool SetupOneShotTool(); if (STOP) return; CServerDoc* pDoc = GetDocument(); LPIMAGE lpImage = pDoc->GetImage(); if (lpImage) { HWND hActiveWnd = GetSafeHwnd(); if (hActiveWnd == hZoomWindow) return; if ( Tool.bActive && Tool.lpToolProc ) DestroyProc( hActiveWnd, 1L ); } }
void doContactSchedd() { int rc; Qmgr_connection *schedd; BaseJob *curr_job; ClassAd *next_ad; char expr_buf[12000]; bool schedd_updates_complete = false; bool schedd_deletes_complete = false; bool add_remove_jobs_complete = false; bool update_jobs_complete = false; bool commit_transaction = true; int failure_line_num = 0; bool send_reschedule = false; std::string error_str = ""; StringList dirty_job_ids; char *job_id_str; PROC_ID job_id; CondorError errstack; dprintf(D_FULLDEBUG,"in doContactSchedd()\n"); initJobExprs(); contactScheddTid = TIMER_UNSET; // vacateJobs ///////////////////////////////////////////////////// if ( pendingScheddVacates.getNumElements() != 0 ) { std::string buff; StringList job_ids; VacateRequest curr_request; int result; ClassAd* rval; pendingScheddVacates.startIterations(); while ( pendingScheddVacates.iterate( curr_request ) != 0 ) { formatstr( buff, "%d.%d", curr_request.job->procID.cluster, curr_request.job->procID.proc ); job_ids.append( buff.c_str() ); } char *tmp = job_ids.print_to_string(); if ( tmp ) { dprintf( D_FULLDEBUG, "Calling vacateJobs on %s\n", tmp ); free(tmp); tmp = NULL; } rval = ScheddObj->vacateJobs( &job_ids, VACATE_FAST, &errstack ); if ( rval == NULL ) { formatstr( error_str, "vacateJobs returned NULL, CondorError: %s!", errstack.getFullText().c_str() ); goto contact_schedd_failure; } else { pendingScheddVacates.startIterations(); while ( pendingScheddVacates.iterate( curr_request ) != 0 ) { formatstr( buff, "job_%d_%d", curr_request.job->procID.cluster, curr_request.job->procID.proc ); if ( !rval->LookupInteger( buff.c_str(), result ) ) { dprintf( D_FULLDEBUG, "vacateJobs returned malformed ad\n" ); EXCEPT( "vacateJobs returned malformed ad" ); } else { dprintf( D_FULLDEBUG, " %d.%d vacate result: %d\n", curr_request.job->procID.cluster, curr_request.job->procID.proc,result); pendingScheddVacates.remove( curr_request.job->procID ); curr_request.result = (action_result_t)result; curr_request.job->SetEvaluateState(); completedScheddVacates.insert( curr_request.job->procID, curr_request ); } } delete rval; } } schedd = ConnectQ( ScheddAddr, QMGMT_TIMEOUT, false, NULL, myUserName, CondorVersion() ); if ( !schedd ) { error_str = "Failed to connect to schedd!"; goto contact_schedd_failure; } // CheckLeases ///////////////////////////////////////////////////// if ( checkLeasesSignaled ) { dprintf( D_FULLDEBUG, "querying for renewed leases\n" ); // Grab the lease attributes of all the jobs in our global hashtable. BaseJob::JobsByProcId.startIterations(); while ( BaseJob::JobsByProcId.iterate( curr_job ) != 0 ) { int new_expiration; rc = GetAttributeInt( curr_job->procID.cluster, curr_job->procID.proc, ATTR_TIMER_REMOVE_CHECK, &new_expiration ); if ( rc < 0 ) { if ( errno == ETIMEDOUT ) { failure_line_num = __LINE__; commit_transaction = false; goto contact_schedd_disconnect; } else { // This job doesn't have doesn't have a lease from // the submitter. Skip it. continue; } } curr_job->UpdateJobLeaseReceived( new_expiration ); } checkLeasesSignaled = false; } // end of handling check leases // AddJobs ///////////////////////////////////////////////////// if ( addJobsSignaled || firstScheddContact ) { int num_ads = 0; dprintf( D_FULLDEBUG, "querying for new jobs\n" ); // Make sure we grab all Globus Universe jobs (except held ones // that we previously indicated we were done with) // when we first start up in case we're recovering from a // shutdown/meltdown. // Otherwise, grab all jobs that are unheld and aren't marked as // currently being managed and aren't marked as not matched. // If JobManaged is undefined, equate it with false. // If Matched is undefined, equate it with true. // NOTE: Schedds from Condor 6.6 and earlier don't include // "(Universe==9)" in the constraint they give to the gridmanager, // so this gridmanager will pull down non-globus-universe ads, // although it won't use them. This is inefficient but not // incorrect behavior. if ( firstScheddContact ) { // Grab all jobs for us to manage. This expression is a // derivative of the expression below for new jobs. We add // "|| Managed =?= TRUE" to also get jobs our previous // incarnation was in the middle of managing when it died // (if it died unexpectedly). With the new term, the // "&& Managed =!= TRUE" from the new jobs expression becomes // superfluous (by boolean logic), so we drop it. sprintf( expr_buf, "%s && %s && ((%s && %s) || %s)", expr_schedd_job_constraint.c_str(), expr_not_completely_done.c_str(), expr_matched_or_undef.c_str(), expr_not_held.c_str(), expr_managed.c_str() ); } else { // Grab new jobs for us to manage sprintf( expr_buf, "%s && %s && %s && %s && %s", expr_schedd_job_constraint.c_str(), expr_not_completely_done.c_str(), expr_matched_or_undef.c_str(), expr_not_held.c_str(), expr_not_managed.c_str() ); } dprintf( D_FULLDEBUG,"Using constraint %s\n",expr_buf); next_ad = GetNextJobByConstraint( expr_buf, 1 ); while ( next_ad != NULL ) { PROC_ID procID; BaseJob *old_job; int job_is_matched = 1; // default to true if not in ClassAd next_ad->LookupInteger( ATTR_CLUSTER_ID, procID.cluster ); next_ad->LookupInteger( ATTR_PROC_ID, procID.proc ); bool job_is_managed = jobExternallyManaged(next_ad); next_ad->LookupBool(ATTR_JOB_MATCHED,job_is_matched); if ( BaseJob::JobsByProcId.lookup( procID, old_job ) != 0 ) { JobType *job_type = NULL; BaseJob *new_job = NULL; // job had better be either managed or matched! (or both) ASSERT( job_is_managed || job_is_matched ); if ( MustExpandJobAd( next_ad ) ) { // Get the expanded ClassAd from the schedd, which // has the GridResource filled in with info from // the matched ad. delete next_ad; next_ad = NULL; next_ad = GetJobAd(procID.cluster,procID.proc); if ( next_ad == NULL && errno == ETIMEDOUT ) { failure_line_num = __LINE__; commit_transaction = false; goto contact_schedd_disconnect; } if ( next_ad == NULL ) { // We may get here if it was not possible to expand // one of the $$() expressions. We don't want to // roll back the transaction and blow away the // hold that the schedd just put on the job, so // simply skip over this ad. dprintf(D_ALWAYS,"Failed to get expanded job ClassAd from Schedd for %d.%d. errno=%d\n",procID.cluster,procID.proc,errno); goto contact_schedd_next_add_job; } } // Search our job types for one that'll handle this job jobTypes.Rewind(); while ( jobTypes.Next( job_type ) ) { if ( job_type->AdMatchFunc( next_ad ) ) { // Found one! dprintf( D_FULLDEBUG, "Using job type %s for job %d.%d\n", job_type->Name, procID.cluster, procID.proc ); break; } } if ( job_type != NULL ) { new_job = job_type->CreateFunc( next_ad ); } else { dprintf( D_ALWAYS, "No handlers for job %d.%d\n", procID.cluster, procID.proc ); new_job = new BaseJob( next_ad ); } ASSERT(new_job); new_job->SetEvaluateState(); dprintf(D_ALWAYS,"Found job %d.%d --- inserting\n", new_job->procID.cluster,new_job->procID.proc); num_ads++; if ( !job_is_managed ) { rc = tSetAttributeString( new_job->procID.cluster, new_job->procID.proc, ATTR_JOB_MANAGED, MANAGED_EXTERNAL); if ( rc < 0 ) { failure_line_num = __LINE__; commit_transaction = false; goto contact_schedd_disconnect; } } } else { // We already know about this job, skip // But also set Managed=true on the schedd so that it won't // keep signalling us about it delete next_ad; rc = tSetAttributeString( procID.cluster, procID.proc, ATTR_JOB_MANAGED, MANAGED_EXTERNAL ); if ( rc < 0 ) { failure_line_num = __LINE__; commit_transaction = false; goto contact_schedd_disconnect; } } contact_schedd_next_add_job: next_ad = GetNextJobByConstraint( expr_buf, 0 ); } // end of while next_ad if ( errno == ETIMEDOUT ) { failure_line_num = __LINE__; commit_transaction = false; goto contact_schedd_disconnect; } dprintf(D_FULLDEBUG,"Fetched %d new job ads from schedd\n",num_ads); } // end of handling add jobs // RemoveJobs ///////////////////////////////////////////////////// // We always want to perform this check. Otherwise, we may overwrite a // REMOVED/HELD/COMPLETED status with something else below. { int num_ads = 0; dprintf( D_FULLDEBUG, "querying for removed/held jobs\n" ); // Grab jobs marked as REMOVED/COMPLETED or marked as HELD that we // haven't previously indicated that we're done with (by setting // JobManaged to "Schedd". sprintf( expr_buf, "(%s) && (%s) && (%s == %d || %s == %d || (%s == %d && %s =?= \"%s\"))", ScheddJobConstraint, expr_not_completely_done.c_str(), ATTR_JOB_STATUS, REMOVED, ATTR_JOB_STATUS, COMPLETED, ATTR_JOB_STATUS, HELD, ATTR_JOB_MANAGED, MANAGED_EXTERNAL ); dprintf( D_FULLDEBUG,"Using constraint %s\n",expr_buf); next_ad = GetNextJobByConstraint( expr_buf, 1 ); while ( next_ad != NULL ) { PROC_ID procID; BaseJob *next_job; int curr_status; next_ad->LookupInteger( ATTR_CLUSTER_ID, procID.cluster ); next_ad->LookupInteger( ATTR_PROC_ID, procID.proc ); next_ad->LookupInteger( ATTR_JOB_STATUS, curr_status ); if ( BaseJob::JobsByProcId.lookup( procID, next_job ) == 0 ) { // Should probably skip jobs we already have marked as // held or removed next_job->JobAdUpdateFromSchedd( next_ad, true ); num_ads++; } else if ( curr_status == REMOVED ) { // If we don't know about the job, act like we got an // ADD_JOBS signal from the schedd the next time we // connect, so that we'll create a Job object for it // and decide how it needs to be handled. // TODO The AddJobs and RemoveJobs queries shoule be // combined into a single query. dprintf( D_ALWAYS, "Don't know about removed job %d.%d. " "Will treat it as a new job to manage\n", procID.cluster, procID.proc ); addJobsSignaled = true; } else { dprintf( D_ALWAYS, "Don't know about held/completed job %d.%d. " "Ignoring it\n", procID.cluster, procID.proc ); } delete next_ad; next_ad = GetNextJobByConstraint( expr_buf, 0 ); } if ( errno == ETIMEDOUT ) { failure_line_num = __LINE__; commit_transaction = false; goto contact_schedd_disconnect; } dprintf(D_FULLDEBUG,"Fetched %d job ads from schedd\n",num_ads); } if ( RemoteCommitTransaction() < 0 ) { failure_line_num = __LINE__; commit_transaction = false; goto contact_schedd_disconnect; } add_remove_jobs_complete = true; // Retrieve dirty attributes ///////////////////////////////////////////////////// if ( updateJobsSignaled ) { dprintf( D_FULLDEBUG, "querying for jobs with attribute updates\n" ); sprintf( expr_buf, "%s && %s && %s && %s", expr_schedd_job_constraint.c_str(), expr_not_completely_done.c_str(), expr_not_held.c_str(), expr_managed.c_str() ); dprintf( D_FULLDEBUG,"Using constraint %s\n",expr_buf); next_ad = GetNextDirtyJobByConstraint( expr_buf, 1 ); while ( next_ad != NULL ) { ClassAd updates; char str[PROC_ID_STR_BUFLEN]; next_ad->LookupInteger( ATTR_CLUSTER_ID, job_id.cluster ); next_ad->LookupInteger( ATTR_PROC_ID, job_id.proc ); if ( GetDirtyAttributes( job_id.cluster, job_id.proc, &updates ) < 0 ) { dprintf( D_ALWAYS, "Failed to retrieve dirty attributes for job %d.%d\n", job_id.cluster, job_id.proc ); failure_line_num = __LINE__; delete next_ad; goto contact_schedd_disconnect; } else { dprintf (D_FULLDEBUG, "Retrieved updated attributes for job %d.%d\n", job_id.cluster, job_id.proc); dPrintAd(D_JOB, updates); } if ( BaseJob::JobsByProcId.lookup( job_id, curr_job ) == 0 ) { curr_job->JobAdUpdateFromSchedd( &updates, false ); ProcIdToStr( job_id, str ); dirty_job_ids.append( str ); } else { dprintf( D_ALWAYS, "Don't know about updated job %d.%d. " "Ignoring it\n", job_id.cluster, job_id.proc ); } delete next_ad; next_ad = GetNextDirtyJobByConstraint( expr_buf, 0 ); } } update_jobs_complete = true; // if ( BeginTransaction() < 0 ) { errno = 0; BeginTransaction(); if ( errno == ETIMEDOUT ) { failure_line_num = __LINE__; commit_transaction = false; goto contact_schedd_disconnect; } // requestJobStatus ///////////////////////////////////////////////////// if ( pendingJobStatus.getNumElements() != 0 ) { JobStatusRequest curr_request; pendingJobStatus.startIterations(); while ( pendingJobStatus.iterate( curr_request ) != 0 ) { int status; rc = GetAttributeInt( curr_request.job_id.cluster, curr_request.job_id.proc, ATTR_JOB_STATUS, &status ); if ( rc < 0 ) { if ( errno == ETIMEDOUT ) { failure_line_num = __LINE__; commit_transaction = false; goto contact_schedd_disconnect; } else { // The job is not in the schedd's job queue. This // probably means that the user did a condor_rm -f, // so return a job status of REMOVED. status = REMOVED; } } // return status dprintf( D_FULLDEBUG, "%d.%d job status: %d\n", curr_request.job_id.cluster, curr_request.job_id.proc, status ); pendingJobStatus.remove( curr_request.job_id ); curr_request.job_status = status; daemonCore->Reset_Timer( curr_request.tid, 0 ); completedJobStatus.insert( curr_request.job_id, curr_request ); } } // Update existing jobs ///////////////////////////////////////////////////// ScheddUpdateRequest *curr_request; pendingScheddUpdates.startIterations(); while ( pendingScheddUpdates.iterate( curr_request ) != 0 ) { curr_job = curr_request->m_job; dprintf(D_FULLDEBUG,"Updating classad values for %d.%d:\n", curr_job->procID.cluster, curr_job->procID.proc); const char *attr_name; const char *attr_value; ExprTree *expr; bool fake_job_in_queue = false; curr_job->jobAd->ResetExpr(); while ( curr_job->jobAd->NextDirtyExpr(attr_name, expr) == true && fake_job_in_queue == false ) { attr_value = ExprTreeToString( expr ); dprintf(D_FULLDEBUG," %s = %s\n",attr_name,attr_value); rc = SetAttribute( curr_job->procID.cluster, curr_job->procID.proc, attr_name, attr_value); if ( rc < 0 ) { if ( errno == ETIMEDOUT ) { failure_line_num = __LINE__; commit_transaction = false; goto contact_schedd_disconnect; } else { // The job is not in the schedd's job queue. This // probably means that the user did a condor_rm -f, // so pretend that all updates for the job succeed. // Otherwise, we'll never make forward progress on // the job. // TODO We should also fake a job status of REMOVED // to the job, so it can do what cleanup it can. fake_job_in_queue = true; break; } } } } if ( RemoteCommitTransaction() < 0 ) { failure_line_num = __LINE__; commit_transaction = false; goto contact_schedd_disconnect; } schedd_updates_complete = true; // Delete existing jobs ///////////////////////////////////////////////////// errno = 0; BeginTransaction(); if ( errno == ETIMEDOUT ) { failure_line_num = __LINE__; commit_transaction = false; goto contact_schedd_disconnect; } pendingScheddUpdates.startIterations(); while ( pendingScheddUpdates.iterate( curr_request ) != 0 ) { curr_job = curr_request->m_job; if ( curr_job->deleteFromSchedd ) { dprintf(D_FULLDEBUG,"Deleting job %d.%d from schedd\n", curr_job->procID.cluster, curr_job->procID.proc); rc = DestroyProc(curr_job->procID.cluster, curr_job->procID.proc); // NOENT means the job doesn't exist. Good enough for us. if ( rc < 0 && rc != DESTROYPROC_ENOENT) { failure_line_num = __LINE__; commit_transaction = false; goto contact_schedd_disconnect; } } } if ( RemoteCommitTransaction() < 0 ) { failure_line_num = __LINE__; commit_transaction = false; goto contact_schedd_disconnect; } schedd_deletes_complete = true; contact_schedd_disconnect: DisconnectQ( schedd, commit_transaction ); if ( add_remove_jobs_complete == true ) { firstScheddContact = false; addJobsSignaled = false; } else { formatstr( error_str, "Schedd connection error during Add/RemoveJobs at line %d!", failure_line_num ); goto contact_schedd_failure; } if ( update_jobs_complete == true ) { updateJobsSignaled = false; } else { formatstr( error_str, "Schedd connection error during dirty attribute update at line %d!", failure_line_num ); goto contact_schedd_failure; } if ( schedd_updates_complete == false ) { formatstr( error_str, "Schedd connection error during updates at line %d!", failure_line_num ); goto contact_schedd_failure; } // Clear dirty bits for all jobs updated if ( !dirty_job_ids.isEmpty() ) { ClassAd *rval; dprintf( D_FULLDEBUG, "Calling clearDirtyAttrs on %d jobs\n", dirty_job_ids.number() ); dirty_job_ids.rewind(); rval = ScheddObj->clearDirtyAttrs( &dirty_job_ids, &errstack ); if ( rval == NULL ) { dprintf(D_ALWAYS, "Failed to notify schedd to clear dirty attributes. CondorError: %s\n", errstack.getFullText().c_str() ); } delete rval; } // Wake up jobs that had schedd updates pending and delete job // objects that wanted to be deleted pendingScheddUpdates.startIterations(); while ( pendingScheddUpdates.iterate( curr_request ) != 0 ) { curr_job = curr_request->m_job; curr_job->jobAd->ClearAllDirtyFlags(); if ( curr_job->deleteFromGridmanager ) { // If the Job object wants to delete the job from the // schedd but we failed to do so, don't delete the job // object yet; wait until we successfully delete the job // from the schedd. if ( curr_job->deleteFromSchedd == true && schedd_deletes_complete == false ) { continue; } // If wantRematch is set, send a reschedule now if ( curr_job->wantRematch ) { send_reschedule = true; } pendingScheddUpdates.remove( curr_job->procID ); pendingScheddVacates.remove( curr_job->procID ); pendingJobStatus.remove( curr_job->procID ); completedJobStatus.remove( curr_job->procID ); completedScheddVacates.remove( curr_job->procID ); delete curr_job; } else { pendingScheddUpdates.remove( curr_job->procID ); if ( curr_request->m_notify ) { curr_job->SetEvaluateState(); } } delete curr_request; } // Poke objects that wanted to be notified when a schedd update completed // successfully (possibly minus deletes) int timer_id; scheddUpdateNotifications.Rewind(); while ( scheddUpdateNotifications.Next( timer_id ) ) { daemonCore->Reset_Timer( timer_id, 0 ); } scheddUpdateNotifications.Clear(); if ( send_reschedule == true ) { ScheddObj->reschedule(); } // Check if we have any jobs left to manage. If not, exit. if ( BaseJob::JobsByProcId.getNumElements() == 0 ) { dprintf( D_ALWAYS, "No jobs left, shutting down\n" ); daemonCore->Send_Signal( daemonCore->getpid(), SIGTERM ); } lastContactSchedd = time(NULL); if ( schedd_deletes_complete == false ) { error_str = "Problem using DestroyProc to delete jobs!"; goto contact_schedd_failure; } scheddFailureCount = 0; // For each job that had dirty attributes, re-evaluate the policy dirty_job_ids.rewind(); while ( (job_id_str = dirty_job_ids.next()) != NULL ) { StrToProcIdFixMe(job_id_str, job_id); if ( BaseJob::JobsByProcId.lookup( job_id, curr_job ) == 0 ) { curr_job->EvalPeriodicJobExpr(); } } dprintf(D_FULLDEBUG,"leaving doContactSchedd()\n"); return; contact_schedd_failure: scheddFailureCount++; if ( error_str == "" ) { error_str = "Failure in doContactSchedd"; } if ( scheddFailureCount >= maxScheddFailures ) { dprintf( D_ALWAYS, "%s\n", error_str.c_str() ); EXCEPT( "Too many failures connecting to schedd!" ); } dprintf( D_ALWAYS, "%s Will retry\n", error_str.c_str() ); lastContactSchedd = time(NULL); RequestContactSchedd(); return; }
int do_Q_request(ReliSock *syscall_sock,bool &may_fork) { int request_num = -1; int rval; syscall_sock->decode(); assert( syscall_sock->code(request_num) ); dprintf(D_SYSCALLS, "Got request #%d\n", request_num); switch( request_num ) { case CONDOR_InitializeConnection: { // dprintf( D_ALWAYS, "InitializeConnection()\n" ); bool authenticated = true; // Authenticate socket, if not already done by daemonCore if( !syscall_sock->triedAuthentication() ) { if( IsDebugLevel(D_SECURITY) ) { MyString methods; SecMan::getAuthenticationMethods( WRITE, &methods ); dprintf(D_SECURITY,"Calling authenticate(%s) in qmgmt_receivers\n", methods.Value()); } CondorError errstack; if( ! SecMan::authenticate_sock(syscall_sock, WRITE, &errstack) ) { // Failed to authenticate dprintf( D_ALWAYS, "SCHEDD: authentication failed: %s\n", errstack.getFullText().c_str() ); authenticated = false; } } if ( authenticated ) { InitializeConnection( syscall_sock->getOwner(), syscall_sock->getDomain() ); } else { InitializeConnection( NULL, NULL ); } return 0; } case CONDOR_InitializeReadOnlyConnection: { // dprintf( D_ALWAYS, "InitializeReadOnlyConnection()\n" ); // Since InitializeConnection() does nothing, and we need // to record the fact that this is a read-only connection, // but we have to do it in the socket (since we don't have // any other persistent data structure, and it's probably // the right place anyway), set the FQU. // // We need to record if this is a read-only connection so that // we can avoid expanding $$ in GetJobAd; simply checking if the // connection is authenticated isn't sufficient, because the // security session cache means that read-only connection could // be authenticated by a previous authenticated connection from // the same address (when using host-based security) less than // the expiration period ago. syscall_sock->setFullyQualifiedUser( "read-only" ); // same as InitializeConnection but no authenticate() InitializeConnection( NULL, NULL ); may_fork = true; return 0; } case CONDOR_SetEffectiveOwner: { MyString owner; int terrno; assert( syscall_sock->get(owner) ); assert( syscall_sock->end_of_message() ); rval = QmgmtSetEffectiveOwner( owner.Value() ); terrno = errno; syscall_sock->encode(); assert( syscall_sock->code(rval) ); if( rval < 0 ) { assert( syscall_sock->code(terrno) ); } assert( syscall_sock->end_of_message() ); char const *fqu = syscall_sock->getFullyQualifiedUser(); dprintf(D_SYSCALLS, "\tSetEffectiveOwner\n"); dprintf(D_SYSCALLS, "\tauthenticated user = '******'\n", fqu ? fqu : ""); dprintf(D_SYSCALLS, "\trequested owner = '%s'\n", owner.Value()); dprintf(D_SYSCALLS, "\trval %d, errno %d\n", rval, terrno); return 0; } case CONDOR_NewCluster: { int terrno; assert( syscall_sock->end_of_message() );; errno = 0; rval = NewCluster( ); terrno = errno; dprintf(D_SYSCALLS, "\tNewCluster: rval = %d, errno = %d\n",rval,terrno ); if ( rval > 0 ) { dprintf( D_AUDIT, *syscall_sock, "Submitting new job %d.0\n", rval ); } syscall_sock->encode(); assert( syscall_sock->code(rval) ); if( rval < 0 ) { assert( syscall_sock->code(terrno) ); } assert( syscall_sock->end_of_message() );; dprintf(D_FULLDEBUG,"schedd: NewCluster rval %d errno %d\n",rval,terrno); return 0; } case CONDOR_NewProc: { int cluster_id = -1; int terrno; assert( syscall_sock->code(cluster_id) ); dprintf( D_SYSCALLS, " cluster_id = %d\n", cluster_id ); assert( syscall_sock->end_of_message() );; errno = 0; rval = NewProc( cluster_id ); terrno = errno; dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, terrno ); if ( rval > 0 ) { dprintf( D_AUDIT, *syscall_sock, "Submitting new job %d.%d\n", cluster_id, rval ); } syscall_sock->encode(); assert( syscall_sock->code(rval) ); if( rval < 0 ) { assert( syscall_sock->code(terrno) ); } assert( syscall_sock->end_of_message() );; dprintf(D_FULLDEBUG,"schedd: NewProc rval %d errno %d\n",rval,terrno); return 0; } case CONDOR_DestroyProc: { int cluster_id = -1; int proc_id = -1; int terrno; assert( syscall_sock->code(cluster_id) ); dprintf( D_SYSCALLS, " cluster_id = %d\n", cluster_id ); assert( syscall_sock->code(proc_id) ); dprintf( D_SYSCALLS, " proc_id = %d\n", proc_id ); assert( syscall_sock->end_of_message() );; errno = 0; rval = DestroyProc( cluster_id, proc_id ); terrno = errno; dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, terrno ); syscall_sock->encode(); assert( syscall_sock->code(rval) ); if( rval < 0 ) { assert( syscall_sock->code(terrno) ); } assert( syscall_sock->end_of_message() );; dprintf(D_FULLDEBUG,"schedd: DestroyProc cluster %d proc %d rval %d errno %d\n",cluster_id,proc_id,rval,terrno); return 0; } case CONDOR_DestroyCluster: { int cluster_id = -1; int terrno; assert( syscall_sock->code(cluster_id) ); dprintf( D_SYSCALLS, " cluster_id = %d\n", cluster_id ); assert( syscall_sock->end_of_message() );; errno = 0; rval = DestroyCluster( cluster_id ); terrno = errno; dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, terrno ); syscall_sock->encode(); assert( syscall_sock->code(rval) ); if( rval < 0 ) { assert( syscall_sock->code(terrno) ); } assert( syscall_sock->end_of_message() );; return 0; } #if 0 case CONDOR_DestroyClusterByConstraint: { char *constraint=NULL; int terrno; assert( syscall_sock->code(constraint) ); assert( syscall_sock->end_of_message() );; errno = 0; rval = DestroyClusterByConstraint( constraint ); terrno = errno; dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, terrno ); syscall_sock->encode(); assert( syscall_sock->code(rval) ); if( rval < 0 ) { assert( syscall_sock->code(terrno) ); } free( (char *)constraint ); assert( syscall_sock->end_of_message() );; return 0; } #endif case CONDOR_SetAttributeByConstraint: case CONDOR_SetAttributeByConstraint2: { char *attr_name=NULL; char *attr_value=NULL; char *constraint=NULL; int terrno; SetAttributeFlags_t flags = 0; assert( syscall_sock->code(constraint) ); dprintf( D_SYSCALLS, " constraint = %s\n",constraint); assert( syscall_sock->code(attr_value) ); assert( syscall_sock->code(attr_name) ); if( request_num == CONDOR_SetAttributeByConstraint2 ) { assert( syscall_sock->code( flags ) ); } assert( syscall_sock->end_of_message() );; if (strcmp (attr_name, ATTR_MYPROXY_PASSWORD) == 0) { errno = 0; dprintf( D_SYSCALLS, "SetAttributeByConstraint (MyProxyPassword) not supported...\n"); rval = 0; terrno = errno; } else { errno = 0; rval = SetAttributeByConstraint( constraint, attr_name, attr_value, flags ); terrno = errno; dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, terrno ); if ( rval == 0 ) { dprintf( D_AUDIT, *syscall_sock, "Set Attribute By Constraint %s, " "%s = %s\n", constraint, attr_name, attr_value); } } syscall_sock->encode(); assert( syscall_sock->code(rval) ); if( rval < 0 ) { assert( syscall_sock->code(terrno) ); } free( (char *)constraint ); free( (char *)attr_value ); free( (char *)attr_name ); assert( syscall_sock->end_of_message() );; return 0; } case CONDOR_SetAttribute: case CONDOR_SetAttribute2: { int cluster_id = -1; int proc_id = -1; char *attr_name=NULL; char *attr_value=NULL; int terrno; SetAttributeFlags_t flags = 0; const char *users_username; const char *condor_username; assert( syscall_sock->code(cluster_id) ); dprintf( D_SYSCALLS, " cluster_id = %d\n", cluster_id ); assert( syscall_sock->code(proc_id) ); dprintf( D_SYSCALLS, " proc_id = %d\n", proc_id ); assert( syscall_sock->code(attr_value) ); assert( syscall_sock->code(attr_name) ); if( request_num == CONDOR_SetAttribute2 ) { assert( syscall_sock->code( flags ) ); } users_username = syscall_sock->getOwner(); condor_username = get_condor_username(); if (attr_name) dprintf(D_SYSCALLS,"\tattr_name = %s\n",attr_name); if (attr_value) dprintf(D_SYSCALLS,"\tattr_value = %s\n",attr_value); assert( syscall_sock->end_of_message() );; // ckireyev: // We do NOT want to include MyProxy password in the ClassAd (since it's a secret) // I'm not sure if this is the best place to do this, but.... if (attr_name && attr_value && strcmp (attr_name, ATTR_MYPROXY_PASSWORD) == 0) { errno = 0; dprintf( D_SYSCALLS, "Got MyProxyPassword, stashing...\n"); rval = SetMyProxyPassword (cluster_id, proc_id, attr_value); terrno = errno; dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, terrno ); } else { errno = 0; rval = SetAttribute( cluster_id, proc_id, attr_name, attr_value, flags ); terrno = errno; dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, terrno ); // If we're modifying a previously-submitted job AND either // the client's username is not HTCondor's (i.e. not a // daemon) OR the client says we should log... if( (cluster_id != active_cluster_num) && (rval == 0) && ( strcmp(users_username, condor_username) || (flags & SHOULDLOG) ) ) { dprintf( D_AUDIT, *syscall_sock, "Set Attribute for job %d.%d, " "%s = %s\n", cluster_id, proc_id, attr_name, attr_value); } } free( (char *)attr_value ); free( (char *)attr_name ); if( flags & SetAttribute_NoAck ) { if( rval < 0 ) { return -1; } } else { syscall_sock->encode(); assert( syscall_sock->code(rval) ); if( rval < 0 ) { assert( syscall_sock->code(terrno) ); } assert( syscall_sock->end_of_message() ); } return 0; } case CONDOR_SetTimerAttribute: { int cluster_id = -1; int proc_id = -1; char *attr_name=NULL; int duration = 0; int terrno; assert( syscall_sock->code(cluster_id) ); dprintf( D_SYSCALLS, " cluster_id = %d\n", cluster_id ); assert( syscall_sock->code(proc_id) ); dprintf( D_SYSCALLS, " proc_id = %d\n", proc_id ); assert( syscall_sock->code(attr_name) ); if (attr_name) dprintf(D_SYSCALLS,"\tattr_name = %s\n",attr_name); assert( syscall_sock->code(duration) ); dprintf(D_SYSCALLS,"\tduration = %d\n",duration); assert( syscall_sock->end_of_message() );; errno = 0; rval = SetTimerAttribute( cluster_id, proc_id, attr_name, duration ); terrno = errno; dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, terrno ); dprintf( D_AUDIT, *syscall_sock, "Set Timer Attribute for job %d.%d, " "attr_name = %s, duration = %d\n", cluster_id, proc_id, attr_name, duration); syscall_sock->encode(); assert( syscall_sock->code(rval) ); if( rval < 0 ) { assert( syscall_sock->code(terrno) ); } free( (char *)attr_name ); assert( syscall_sock->end_of_message() );; return 0; } case CONDOR_BeginTransaction: { int terrno; assert( syscall_sock->end_of_message() );; errno = 0; rval = 0; // BeginTransaction returns void (sigh), so always success BeginTransaction( ); terrno = errno; dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, terrno ); syscall_sock->encode(); assert( syscall_sock->code(rval) ); if( rval < 0 ) { assert( syscall_sock->code(terrno) ); } assert( syscall_sock->end_of_message() );; return 0; } case CONDOR_AbortTransaction: { int terrno; assert( syscall_sock->end_of_message() );; errno = 0; rval = 0; // AbortTransaction returns void (sigh), so always success AbortTransaction( ); terrno = errno; dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, terrno ); syscall_sock->encode(); assert( syscall_sock->code(rval) ); if( rval < 0 ) { assert( syscall_sock->code(terrno) ); } assert( syscall_sock->end_of_message() );; return 0; } case CONDOR_CommitTransactionNoFlags: case CONDOR_CommitTransaction: { int terrno; int flags; if( request_num == CONDOR_CommitTransaction ) { assert( syscall_sock->code(flags) ); } else { flags = 0; } assert( syscall_sock->end_of_message() );; errno = 0; CondorError errstack; rval = CheckTransaction( flags, & errstack ); terrno = errno; dprintf( D_SYSCALLS, "\tflags = %d, rval = %d, errno = %d\n", flags, rval, terrno ); if( rval >= 0 ) { errno = 0; CommitTransaction( flags ); // CommitTransaction() never returns on failure rval = 0; terrno = errno; dprintf( D_SYSCALLS, "\tflags = %d, rval = %d, errno = %d\n", flags, rval, terrno ); } syscall_sock->encode(); assert( syscall_sock->code(rval) ); if( rval < 0 ) { assert( syscall_sock->code(terrno) ); const CondorVersionInfo *vers = syscall_sock->get_peer_version(); if (vers && vers->built_since_version(8, 3, 4)) { // Send a classad, for less backwards-incompatibility. int code = 1; const char * reason = "QMGMT rejected job submission."; if( errstack.subsys() ) { code = 2; reason = errstack.message(); } ClassAd reply; reply.Assign( "ErrorCode", code ); reply.Assign( "ErrorReason", reason ); assert( putClassAd( syscall_sock, reply ) ); } } assert( syscall_sock->end_of_message() );; return 0; } case CONDOR_GetAttributeFloat: { int cluster_id = -1; int proc_id = -1; char *attr_name=NULL; float value = 0.0; int terrno; assert( syscall_sock->code(cluster_id) ); dprintf( D_SYSCALLS, " cluster_id = %d\n", cluster_id ); assert( syscall_sock->code(proc_id) ); dprintf( D_SYSCALLS, " proc_id = %d\n", proc_id ); assert( syscall_sock->code(attr_name) ); assert( syscall_sock->end_of_message() );; errno = 0; if( QmgmtMayAccessAttribute( attr_name ) ) { rval = GetAttributeFloat( cluster_id, proc_id, attr_name, &value ); } else { rval = -1; } terrno = errno; dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, terrno ); syscall_sock->encode(); assert( syscall_sock->code(rval) ); if( rval < 0 ) { assert( syscall_sock->code(terrno) ); } if( rval >= 0 ) { assert( syscall_sock->code(value) ); } free( (char *)attr_name ); assert( syscall_sock->end_of_message() );; return 0; } case CONDOR_GetAttributeInt: { int cluster_id = -1; int proc_id = -1; char *attr_name=NULL; int value = 0; int terrno; assert( syscall_sock->code(cluster_id) ); dprintf( D_SYSCALLS, " cluster_id = %d\n", cluster_id ); assert( syscall_sock->code(proc_id) ); dprintf( D_SYSCALLS, " proc_id = %d\n", proc_id ); assert( syscall_sock->code(attr_name) ); dprintf( D_SYSCALLS, " attr_name = %s\n", attr_name ); assert( syscall_sock->end_of_message() );; errno = 0; if( QmgmtMayAccessAttribute( attr_name ) ) { rval = GetAttributeInt( cluster_id, proc_id, attr_name, &value ); } else { rval = -1; } terrno = errno; if (rval < 0) { dprintf( D_SYSCALLS, "GetAttributeInt(%d, %d, %s) not found.\n", cluster_id, proc_id, attr_name); } else { dprintf( D_SYSCALLS, " value: %d\n", value ); dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, terrno ); } syscall_sock->encode(); assert( syscall_sock->code(rval) ); if( rval < 0 ) { assert( syscall_sock->code(terrno) ); } if( rval >= 0 ) { assert( syscall_sock->code(value) ); } free( (char *)attr_name ); assert( syscall_sock->end_of_message() );; return 0; } case CONDOR_GetAttributeString: { int cluster_id = -1; int proc_id = -1; char *attr_name=NULL; char *value = NULL; int terrno; assert( syscall_sock->code(cluster_id) ); dprintf( D_SYSCALLS, " cluster_id = %d\n", cluster_id ); assert( syscall_sock->code(proc_id) ); dprintf( D_SYSCALLS, " proc_id = %d\n", proc_id ); assert( syscall_sock->code(attr_name) ); assert( syscall_sock->end_of_message() );; errno = 0; if( QmgmtMayAccessAttribute( attr_name ) ) { rval = GetAttributeStringNew( cluster_id, proc_id, attr_name, &value ); } else { rval = -1; } terrno = errno; dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, terrno ); syscall_sock->encode(); assert( syscall_sock->code(rval) ); if( rval < 0 ) { assert( syscall_sock->code(terrno) ); } if( rval >= 0 ) { assert( syscall_sock->code(value) ); } free( (char *)value ); free( (char *)attr_name ); assert( syscall_sock->end_of_message() );; return 0; } case CONDOR_GetAttributeExpr: { int cluster_id = -1; int proc_id = -1; char *attr_name=NULL; int terrno; assert( syscall_sock->code(cluster_id) ); dprintf( D_SYSCALLS, " cluster_id = %d\n", cluster_id ); assert( syscall_sock->code(proc_id) ); dprintf( D_SYSCALLS, " proc_id = %d\n", proc_id ); assert( syscall_sock->code(attr_name) ); assert( syscall_sock->end_of_message() );; char *value = NULL; errno = 0; if( QmgmtMayAccessAttribute( attr_name ) ) { rval = GetAttributeExprNew( cluster_id, proc_id, attr_name, &value ); } else { rval = -1; } terrno = errno; dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, terrno ); syscall_sock->encode(); if ( !syscall_sock->code(rval) ) { free(value); return -1; } if( rval < 0 ) { if ( !syscall_sock->code(terrno) ) { free(value); return -1; } } if( rval >= 0 ) { if ( !syscall_sock->code(value) ) { free(value); return -1; } } free( (char *)value ); free( (char *)attr_name ); assert( syscall_sock->end_of_message() );; return 0; } case CONDOR_GetDirtyAttributes: { int cluster_id = -1; int proc_id = -1; ClassAd updates; int terrno; assert( syscall_sock->code(cluster_id) ); dprintf( D_SYSCALLS, " cluster_id = %d\n", cluster_id ); assert( syscall_sock->code(proc_id) ); dprintf( D_SYSCALLS, " proc_id = %d\n", proc_id ); assert( syscall_sock->end_of_message() );; errno = 0; rval = GetDirtyAttributes( cluster_id, proc_id, &updates ); terrno = errno; dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, terrno ); syscall_sock->encode(); if ( !syscall_sock->code(rval) ) { return -1; } if( rval < 0 ) { if ( !syscall_sock->code(terrno) ) { return -1; } } if( rval >= 0 ) { assert( putClassAd(syscall_sock, updates) ); } assert( syscall_sock->end_of_message() );; return 0; } case CONDOR_DeleteAttribute: { int cluster_id = -1; int proc_id = -1; char *attr_name=NULL; int terrno; assert( syscall_sock->code(cluster_id) ); dprintf( D_SYSCALLS, " cluster_id = %d\n", cluster_id ); assert( syscall_sock->code(proc_id) ); dprintf( D_SYSCALLS, " proc_id = %d\n", proc_id ); assert( syscall_sock->code(attr_name) ); assert( syscall_sock->end_of_message() );; errno = 0; rval = DeleteAttribute( cluster_id, proc_id, attr_name ); terrno = errno; dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, terrno ); syscall_sock->encode(); assert( syscall_sock->code(rval) ); if( rval < 0 ) { assert( syscall_sock->code(terrno) ); } free( (char *)attr_name ); assert( syscall_sock->end_of_message() );; return 0; } case CONDOR_GetJobAd: { int cluster_id = -1; int proc_id = -1; ClassAd *ad = NULL; int terrno; bool delete_ad = false; assert( syscall_sock->code(cluster_id) ); dprintf( D_SYSCALLS, " cluster_id = %d\n", cluster_id ); assert( syscall_sock->code(proc_id) ); dprintf( D_SYSCALLS, " proc_id = %d\n", proc_id ); assert( syscall_sock->end_of_message() );; // dprintf( D_ALWAYS, "(%d.%d) isAuthenticated() = %d\n", cluster_id, proc_id, syscall_sock->isAuthenticated() ); // dprintf( D_ALWAYS, "(%d.%d) getOwner() = %s\n", cluster_id, proc_id, syscall_sock->getOwner() ); errno = 0; // Only fetch the jobad for legal values of cluster/proc if( cluster_id >= 1 ) { if( proc_id >= 0 ) { const char * fqu = syscall_sock->getFullyQualifiedUser(); if( fqu != NULL && strcmp( fqu, "read-only" ) != 0 ) { // expand $$() macros in the jobad as required by GridManager. // The GridManager depends on the fact that the following call // expands $$ and saves the expansions to disk in case of // restart. ad = GetJobAd_as_ClassAd( cluster_id, proc_id, true, true ); delete_ad = true; // note : since we expanded the ad, ad is now a deep // copy of the ad in memory, so we must delete it below. } else { ad = GetJobAd_as_ClassAd( cluster_id, proc_id, false, false ); } } else if( proc_id == -1 ) { // allow cluster ad to be queried as required by preen, but // do NOT ask to expand $$() macros in a cluster ad! ad = GetJobAd_as_ClassAd( cluster_id, proc_id, false, false ); } } terrno = errno; rval = ad ? 0 : -1; dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, terrno ); syscall_sock->encode(); assert( syscall_sock->code(rval) ); if( rval < 0 ) { assert( syscall_sock->code(terrno) ); } if( rval >= 0 ) { assert( putClassAd(syscall_sock, *ad, PUT_CLASSAD_NO_PRIVATE) ); } // If we called GetJobAd() with the third bool argument set // to True (expandedAd), it does a deep copy of the ad in the // queue in order to expand the $$() attributes. So we must // delete it. if (delete_ad) delete ad; assert( syscall_sock->end_of_message() );; return 0; } case CONDOR_GetJobByConstraint: { char *constraint=NULL; ClassAd *ad; int terrno; assert( syscall_sock->code(constraint) ); assert( syscall_sock->end_of_message() );; errno = 0; ad = GetJobByConstraint_as_ClassAd( constraint ); terrno = errno; rval = ad ? 0 : -1; dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, terrno ); syscall_sock->encode(); assert( syscall_sock->code(rval) ); if( rval < 0 ) { assert( syscall_sock->code(terrno) ); } if( rval >= 0 ) { assert( putClassAd(syscall_sock, *ad, PUT_CLASSAD_NO_PRIVATE) ); } FreeJobAd(ad); free( (char *)constraint ); assert( syscall_sock->end_of_message() );; return 0; } case CONDOR_GetNextJob: { ClassAd *ad; int initScan = 0; int terrno; assert( syscall_sock->code(initScan) ); dprintf( D_SYSCALLS, " initScan = %d\n", initScan ); assert( syscall_sock->end_of_message() );; errno = 0; ad = GetNextJob( initScan ); terrno = errno; rval = ad ? 0 : -1; dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, terrno ); syscall_sock->encode(); assert( syscall_sock->code(rval) ); if( rval < 0 ) { assert( syscall_sock->code(terrno) ); } if( rval >= 0 ) { assert( putClassAd(syscall_sock, *ad, PUT_CLASSAD_NO_PRIVATE) ); } FreeJobAd(ad); assert( syscall_sock->end_of_message() );; return 0; } case CONDOR_GetNextJobByConstraint: { char *constraint=NULL; ClassAd *ad; int initScan = 0; int terrno; assert( syscall_sock->code(initScan) ); dprintf( D_SYSCALLS, " initScan = %d\n", initScan ); if ( !(syscall_sock->code(constraint)) ) { if (constraint != NULL) { free(constraint); constraint = NULL; } return -1; } assert( syscall_sock->end_of_message() );; errno = 0; ad = GetNextJobByConstraint( constraint, initScan ); terrno = errno; rval = ad ? 0 : -1; dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, terrno ); syscall_sock->encode(); assert( syscall_sock->code(rval) ); if( rval < 0 ) { assert( syscall_sock->code(terrno) ); } if( rval >= 0 ) { assert( putClassAd(syscall_sock, *ad, PUT_CLASSAD_NO_PRIVATE) ); } FreeJobAd(ad); free( (char *)constraint ); assert( syscall_sock->end_of_message() );; return 0; } case CONDOR_GetNextDirtyJobByConstraint: { char *constraint=NULL; ClassAd *ad; int initScan = 0; int terrno; assert( syscall_sock->code(initScan) ); dprintf( D_SYSCALLS, " initScan = %d\n", initScan ); if ( !(syscall_sock->code(constraint)) ) { if (constraint != NULL) { free(constraint); constraint = NULL; } return -1; } assert( syscall_sock->end_of_message() ); errno = 0; ad = GetNextDirtyJobByConstraint( constraint, initScan ); terrno = errno; rval = ad ? 0 : -1; dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, terrno ); syscall_sock->encode(); assert( syscall_sock->code(rval) ); if( rval < 0 ) { assert( syscall_sock->code(terrno) ); } if( rval >= 0 ) { assert( putClassAd(syscall_sock, *ad, PUT_CLASSAD_NO_PRIVATE) ); } FreeJobAd(ad); free( (char *)constraint ); assert( syscall_sock->end_of_message() ); return 0; } case CONDOR_SendSpoolFile: { char *filename=NULL; int terrno; assert( syscall_sock->code(filename) ); assert( syscall_sock->end_of_message() );; errno = 0; rval = SendSpoolFile( filename ); terrno = errno; dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, terrno ); #if 0 syscall_sock->encode(); assert( syscall_sock->code(rval) ); if( rval < 0 ) { assert( syscall_sock->code(terrno) ); } assert( syscall_sock->end_of_message() );; #endif free( (char *)filename ); return 0; } case CONDOR_SendSpoolFileIfNeeded: { int terrno; ClassAd ad; assert( getClassAd(syscall_sock, ad) ); assert( syscall_sock->end_of_message() );; errno = 0; rval = SendSpoolFileIfNeeded(ad); terrno = errno; dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, terrno ); return 0; } case CONDOR_GetAllJobsByConstraint: { char *constraint=NULL; char *projection=NULL; ClassAd *ad; int terrno; int initScan = 1; classad::References proj; if ( !(syscall_sock->code(constraint)) ) { if (constraint != NULL) { free(constraint); constraint = NULL; } return -1; } if ( !(syscall_sock->code(projection)) ) { if (projection != NULL) { free(constraint); free(projection); projection = NULL; } return -1; } dprintf( D_SYSCALLS, " constraint = %s\n", constraint ); dprintf( D_SYSCALLS, " projection = %s\n", projection ? projection : ""); assert( syscall_sock->end_of_message() );; // if there is a projection, convert it into a set of attribute names if (projection) { StringTokenIterator list(projection); const std::string * attr; while ((attr = list.next_string())) { proj.insert(*attr); } } syscall_sock->encode(); do { errno = 0; ad = GetNextJobByConstraint( constraint, initScan ); initScan=0; // one first time through, otherwise 0 terrno = errno; rval = ad ? 0 : -1; dprintf( D_SYSCALLS, "\trval = %d, errno = %d\n", rval, terrno ); assert( syscall_sock->code(rval) ); if( rval < 0 ) { assert( syscall_sock->code(terrno) ); } if( rval >= 0 ) { assert( putClassAd(syscall_sock, *ad, PUT_CLASSAD_NO_PRIVATE, proj.empty() ? NULL : &proj) ); FreeJobAd(ad); } } while (rval >= 0); assert( syscall_sock->end_of_message() );; free( (char *)constraint ); free( (char *)projection ); return 0; } case CONDOR_CloseSocket: { assert( syscall_sock->end_of_message() );; return -1; } } /* End of switch */ return -1; } /* End of function */
long DoCommand( HWND hWindow, WPARAM wParam, LPARAM lParam ) /***********************************************************************/ { FNAME szFileName; LPFRAME lpFrame; LPOBJECT lpObject, lpBase; RECT rect, rMask, rTemp, rAll; HWND hWnd; STRING szString; int i, idFileType, x, y, dx, dy; BOOL fDoZoom, bPrint, fHasZoom; LPSTR lpszCmdLine; HGLOBAL hMem; ITEMID idDataType; DWORD dwReturn; int NewShape; UINT wID; SoundStartID( wParam, NO/*bLoop*/, NULL/*hInstance*/ ); /* WIN16: ID = wParam ctrl handle = LOWORD(lParam) notify code = HIWORD(lParam) WIN32: ID = LOWORD(wParam) ctrl handle = lParam notify code = HIWORD(wParam) */ #ifdef WIN32 wID = LOWORD(wParam); #else wID = wParam; #endif switch (wID) { case IDM_EXIT: DeactivateTool(); PostMessage( hWndAstral, WM_CLOSE, 0, 0L); Delay (750); break; case IDM_CLOSE: DeactivateTool(); /* Check to see if the image needs to be saved */ if ( !ConfirmClose(NO,NO) ) break; CloseImage( NO, lpImage ); // Close the active image break; case IDM_ABOUT: /* Bring up the modal 'About' dialog box */ AstralDlg( NO|2, hInstAstral, hWindow, IDD_ABOUT, DlgAboutProc); break; case IDM_NEXTPAGE: if ( !lpImage ) break; DeactivateTool(); SendMessage( lpImage->hWnd, WM_SYSCOMMAND, SC_NEXTWINDOW, 0L ); break; case IDM_NEW: DeactivateTool(); SoundStartResource( "magic01", NO, NULL ); AstralCursor( IDC_WAIT ); New( Control.NewWidth, Control.NewHeight, Control.NewResolution, Control.NewDepth ); AstralCursor( NULL ); break; case IDM_OPEN: DeactivateTool(); /* Bring up the modal 'File Open' box */ if ( !(dwReturn = DoOpenDlg( hWindow, IDD_OPEN, Save.FileType, szFileName, NO )) ) break; idFileType = LOWORD( dwReturn ); Save.FileType = idFileType; PutDefaultInt( "FileType", idFileType - IDN_TIFF ); AstralImageLoad( idFileType, szFileName, MAYBE, YES ); break; case IDM_ALTOPEN: DeactivateTool(); // Command line sent from a second instance prior to it closing /* If the caller passed in a file name, try to load it or print it */ if ( !(lpszCmdLine = (LPSTR)lParam) ) break; HandleCommandLine( hWindow, lpszCmdLine, &bPrint ); break; case IDM_SAVE: DeactivateTool(); HandleSaveCommand(hWindow, wID, YES); break; case IDM_SAVEAS: DeactivateTool(); HandleSaveCommand(hWindow, wID, YES); break; case IDM_SAVESPECIAL: DeactivateTool(); HandleSaveCommand(hWindow, wID, YES); break; case IDM_SAVEWALLPAPER: DeactivateTool(); SaveWallpaper( "CRAYOLA", NO/*fTiled*/ ); break; case IDM_REVERT: if ( !lpImage ) break; DeactivateTool(); if ( lpImage->fUntitled ) // If the picture doesn't have a name, get out break; if ( ImgChanged(lpImage) ) { /* Check to see if its OK to trash changes */ if ( AstralOKCancel(IDS_OKTOREVERT, (LPSTR)lpImage->CurFile) == IDCANCEL ) break; } lstrcpy( szFileName, lpImage->CurFile ); idFileType = lpImage->FileType; fDoZoom = IsZoomed(lpImage->hWnd); fHasZoom = Window.fHasZoom; CloseImage( NO, lpImage ); // Close the active image if ( !AstralImageLoad( idFileType, szFileName, fDoZoom, YES ) ) break; break; case IDM_RECALLIMAGE0: case IDM_RECALLIMAGE1: case IDM_RECALLIMAGE2: case IDM_RECALLIMAGE3: case IDM_RECALLIMAGE4: case IDM_RECALLIMAGE5: case IDM_RECALLIMAGE6: case IDM_RECALLIMAGE7: case IDM_RECALLIMAGE8: case IDM_RECALLIMAGE9: DeactivateTool(); GetMenuString( GetMenu(hWindow), wID, szFileName, sizeof(szFileName), MF_BYCOMMAND ); i = 0; while ( szFileName[i] && szFileName[i] != ' ' ) i++; // Skip over the numeric id in the string (3. junk.tif) lstrcpy(szString, &szFileName[i+1]); GetRecallFileName(szString); AstralImageLoad( NULL, szString, MAYBE, YES ); break; case IDM_PRINT: if ( !lpImage ) break; DeactivateTool(); AstralCursor( IDC_WAIT ); DoPrintSizeInits(); SoundStartResource( "print", YES, NULL ); PrintFile( hWindow, filename(lpImage->CurFile), YES, lpImage, NULL ); SoundStop(); AstralCursor( NULL ); break; case IDM_PRINTSETUP: /* Bring up the setup dialog box for the active printer */ AstralDlg( NO|2, hInstAstral, hWindow, IDD_PRINTSETUP, DlgPrintSetupProc); break; case IDC_SOUND: SoundToggle(); break; case IDM_UNDO: if ( !lpImage ) break; DeactivateTool(); ImgEditUndo(lpImage, YES, NO); break; case IDM_CUT: case IDM_COPY: if ( !lpImage ) break; DeactivateTool(); // Create the clipboard files from the image ProgressBegin(1, IDS_PROGCOPY); if ( !ImgWriteClipOut( lpImage, NULL, NULL, &rMask, lpImage->DataType ) ) { ProgressEnd(); Message(IDS_EMEMALLOC); break; } ProgressEnd(); OpenClipboard(hWindow); EmptyClipboard(); // Passing a NULL data handle in SetClipboardData() means that // the data will be requested in a WM_RENDERFORMAT message hMem = ConstructObject( lpImage, IsRectEmpty(&rMask)? (LPRECT)NULL : (LPRECT)&rMask ); if ( pOLE ) { // Any data put on before Native will become staticly copied SetClipboardData( pOLE->cfNative, NULL ); SetClipboardData( pOLE->cfOwnerLink, hMem ); } SetClipboardData( CF_DIB, NULL ); if ( Control.DoPicture ) SetClipboardData( CF_METAFILEPICT, NULL ); if ( Control.DoBitmap ) SetClipboardData( CF_BITMAP, NULL ); SetClipboardData( CF_PALETTE, NULL ); SetClipboardData( Control.cfImage, NULL ); if ( pOLE && wID == IDM_COPY && !lpImage->fUntitled ) { // ObjectLink is retrieved during a Paste Link... SetClipboardData( pOLE->cfObjectLink, hMem ); } CloseClipboard(); if ( wID == IDM_COPY ) break; // else fall through to IDM_DELETE case IDM_DELETE: if ( !lpImage ) break; { COLORINFO ColorInfo; DeactivateTool(); ColorInfo.gray = 255; SetColorInfo( &ColorInfo, &ColorInfo, CS_GRAY ); TintFill( lpImage, &ColorInfo, 255, MM_NORMAL, wID == IDM_CUT ? IDS_UNDOCUT : IDS_UNDODELETE ); } break; case IDM_PASTE: if ( !lpImage ) break; case IDM_PASTEASNEW: if ( !OpenClipboard(hWndAstral) ) { Message( IDS_ECLIPOPEN ); break; } if ( !IsClipboardFormatAvailable(CF_DIB) && !IsClipboardFormatAvailable(CF_BITMAP) && !IsClipboardFormatAvailable(Control.cfImage) ) { Message( IDS_ECLIPOPEN ); CloseClipboard(); break; } CloseClipboard(); DeactivateTool(); // First put clipboard contents into a file(s) AstralCursor(IDC_WAIT); if ( !PasteFromClipboard( hWindow, (wID == IDM_PASTE) /*fNeedMask*/ ) ) { AstralCursor(NULL); Message(IDS_EMEMALLOC); break; } if ( wID == IDM_PASTE ) { ProgressBegin(1, IDS_PROGPASTECLIP); TransformObjectsStart( YES/*fNewObject*/ ); if ( ImgCreateClipInObject( lpImage, NO ) ) ; ProgressEnd(); } else if ( wID == IDM_PASTEASNEW ) { if ( lpFrame = AstralFrameLoad( Names.PasteImageFile, -1, &idDataType, &idFileType) ) { if ( NewImageWindow( NULL, // lpOldFrame NULL, // Name lpFrame, // lpNewFrame idFileType, // lpImage->FileType idDataType, // lpImage->DataType FALSE, // New view? IMG_DOCUMENT, // lpImage->DocumentType NULL, // lpImage->ImageName MAYBE ) ) lpImage->fChanged = YES; } } break; case IDM_ESCAPE: if (!lpImage) break; if (lpImage->hWnd == hZoomWindow) break; if ( Tool.bActive && Tool.lpToolProc ) DestroyProc( lpImage->hWnd, 1L ); break; case IDM_SIZEUP: case IDM_SIZEDOWN: if (!Retouch.hBrush) break; SetFocus( hWindow ); // Take focus away from any controls if ( Retouch.BrushShape == IDC_BRUSHCUSTOM ) break; if ( wID == IDM_SIZEUP ) { if( bHexBrush && ( Retouch.BrushSize % 2 == 0 ) && ( Retouch.BrushSize > 6 )) Retouch.BrushSize += 2; else Retouch.BrushSize++; } else { if( bHexBrush && ( Retouch.BrushSize % 2 == 0 ) && ( Retouch.BrushSize > 6 )) Retouch.BrushSize -= 2; else Retouch.BrushSize--; } if ( Retouch.BrushSize < 1 || Retouch.BrushSize > MAX_BRUSH_SIZE ) { Retouch.BrushSize = bound( Retouch.BrushSize, 1,MAX_BRUSH_SIZE); MessageBeep(0); break; } if (lpImage) DisplayBrush(0, 0, 0, OFF); SetMgxBrushSize(Retouch.hBrush, Retouch.BrushSize); if (lpImage && Window.hCursor == Window.hNullCursor) DisplayBrush(lpImage->hWnd, 32767, 32767, ON); if ( Tool.hRibbon ) SetSlide( Tool.hRibbon, IDC_BRUSHSIZE, Retouch.BrushSize ); break; case IDM_SHAPEUP: case IDM_SHAPEDOWN: if (!Retouch.hBrush) break; SetFocus( hWindow ); // Take focus away from any controls NewShape = Retouch.BrushShape; if ( wID == IDM_SHAPEUP ) NewShape++; else NewShape--; if ( NewShape > IDC_BRUSHCUSTOM ) NewShape = IDC_BRUSHCIRCLE; if ( NewShape < IDC_BRUSHCIRCLE ) NewShape = IDC_BRUSHCUSTOM; if (lpImage) DisplayBrush(0, 0, 0, OFF); if (!SetMgxBrushShape(Retouch.hBrush, NewShape, Names.CustomBrush)) { NewShape = IDC_BRUSHCIRCLE; SetMgxBrushShape(Retouch.hBrush, NewShape, Names.CustomBrush); } Retouch.BrushShape = NewShape; if (lpImage && Window.hCursor == Window.hNullCursor) DisplayBrush(lpImage->hWnd, 32767, 32767, ON); if ( Tool.hRibbon ) { CheckComboItem( Tool.hRibbon, IDC_BRUSHSHAPE, IDC_BRUSHCIRCLE, IDC_BRUSHCUSTOMNEW, Retouch.BrushShape ); SendMessage( Tool.hRibbon, WM_CONTROLENABLE, 0, 0L ); } break; case IDM_MOVEUP: case IDM_MOVEDOWN: case IDM_MOVELEFT: case IDM_MOVERIGHT: if (!lpImage) break; lpBase = ImgGetBase(lpImage); if (ImgGetSelObject(lpImage, NULL) == lpBase) break; dx = dy = 0; if (wID == IDM_MOVEUP) --dy; if (wID == IDM_MOVEDOWN) ++dy; if (wID == IDM_MOVELEFT) --dx; if (wID == IDM_MOVERIGHT) ++dx; lpObject = NULL; while (lpObject = ImgGetSelObject(lpImage, lpObject)) { rect = lpObject->rObject; OffsetRect(&rect, dx, dy); if (!AstralIntersectRect(&rTemp, &lpBase->rObject, &rect)) break; } if (lpObject) break; AstralSetRectEmpty(&rAll); lpObject = NULL; while (lpObject = ImgGetSelObject(lpImage, lpObject)) { rect = lpObject->rObject; OffsetRect(&lpObject->rObject, dx, dy); AstralUnionRect(&rAll, &rAll, &lpObject->rObject); if (!lpObject->Pixmap.fNewFrame && EqualRect(&rect, &lpObject->rUndoObject)) lpObject->rUndoObject = lpObject->rObject; UpdateImage(&rect, TRUE); UpdateImage(&lpObject->rObject, TRUE); } if (wID == IDM_MOVEUP) { x = (rAll.left + rAll.right)/2; y = rAll.top; } else if (wID == IDM_MOVEDOWN) { x = (rAll.left + rAll.right)/2; y = rAll.bottom; } else if (wID == IDM_MOVELEFT) { x = rAll.left; y = (rAll.top + rAll.bottom)/2; } else if (wID == IDM_MOVERIGHT) { x = rAll.right; y = (rAll.top + rAll.bottom)/2; } File2Display(&x, &y); AutoScroll(lpImage->hWnd, x, y); AstralUpdateWindow(lpImage->hWnd); DisplayInfo(-1, &rAll); break; case IDM_LASTTOOL: DeactivateTool(); if ( Tool.idLast && (hWnd = AstralDlgGet(IDD_MAIN)) ) SendMessage( hWnd, WM_COMMAND, Tool.idLast, 2L); break; case IDM_PREF: // prevent problems if running animations and they change // the wave mix dll setting in preferences StopAnimation(); AstralDlg( NO|2, hInstAstral, hWindow, IDD_PREF, DlgPrefProc ); break; case IDC_VIEWLAST: // duplicate of function in the view ribbon if ( !lpImage ) break; RevertLastView(); break; // case IDC_VIEWFULL: // duplicate of function in the view ribbon // if ( !lpImage ) // break; // AstralDlg( NO, hInstAstral, hWindow, IDD_VIEWFULL, DlgFullScreenViewProc ); // break; case IDC_VIEWALL: // duplicate of function in the view ribbon if ( !lpImage ) break; ViewAll(); break; case IDC_ZOOMIN: // duplicate of function in the view ribbon if ( !lpImage ) break; if (!lpImage->lpDisplay) break; if (!lpImage->lpDisplay->ViewPercentage) break; x = ( lpImage->lpDisplay->FileRect.left + lpImage->lpDisplay->FileRect.right ) / 2; y = ( lpImage->lpDisplay->FileRect.top + lpImage->lpDisplay->FileRect.bottom ) / 2; SaveLastView(); Zoom(x,y, +100, YES, ( View.ZoomWindow ^ CONTROL ) ); break; case IDC_ZOOMOUT: // duplicate of function in the view ribbon if ( !lpImage ) break; if (!lpImage->lpDisplay) break; if (!lpImage->lpDisplay->ViewPercentage) break; x = ( lpImage->lpDisplay->FileRect.left + lpImage->lpDisplay->FileRect.right ) / 2; y = ( lpImage->lpDisplay->FileRect.top + lpImage->lpDisplay->FileRect.bottom ) / 2; SaveLastView(); Zoom(x,y, -100, YES,( View.ZoomWindow ^ CONTROL ) ); break; case IDM_HELP: Control.Hints = !Control.Hints; PutDefInt (Control.Hints,Control.Hints); break; default: return( FALSE ); } return( TRUE ); }