bool
StreamHandler::Reconnect() {
HandlerType handler_mode;
dprintf(D_ALWAYS, "Streaming i/o handler reconnecting %s to shadow\n", filename.Value());
if(is_output) {
handler_mode = HANDLE_READ;
} else {
handler_mode = HANDLE_WRITE;
}
// Never permit truncation on a reconnect; what sense does that make?
flags = flags & (~O_TRUNC);
remote_fd = REMOTE_CONDOR_open(filename.Value(),(open_flags_t)flags,0777);
if(remote_fd<0) {
EXCEPT("Couldn't reopen %s to stream %s: %s",filename.Value(),streamname.Value(),strerror(errno));
}
daemonCore->Register_Pipe(handler_pipe,"Job I/O Pipe",static_cast<PipeHandlercpp>(&StreamHandler::Handler),"Stream I/O Handler",this,handler_mode);
connected = true;
if(is_output) {
VerifyOutputFile();
// We don't always need to do this write, but it is cheap to do
// and always doing it makes it easier to test
errno = 0;
dprintf(D_ALWAYS, "Retrying streaming write to %s of %d bytes at %ld after reconnect\n", filename.Value(), pending, (long)offset);
REMOTE_CONDOR_lseek(remote_fd,offset,SEEK_SET);
if (errno == ETIMEDOUT) {
Disconnect();
return false;
}
errno = 0;
int actual = REMOTE_CONDOR_write(remote_fd,buffer,pending);
if (errno == ETIMEDOUT) {
Disconnect();
return 0;
return false;
}
if(actual!=pending) {
EXCEPT("StreamHandler: %s: couldn't write to %s: %s (%d!=%d)",streamname.Value(),filename.Value(),strerror(errno),actual,pending);
}
dprintf(D_SYSCALLS,"StreamHandler: %s: %d bytes written to %s\n",streamname.Value(),pending,filename.Value());
offset+=actual;
} else {
// In the input case, we never wrote to the job pipe,
// and reading is idempotent, so just try again.
this->Handler(0);
}
return true;
}
bool StreamHandler::Init( const char *fn, const char *sn, bool io )
{
int flags;
int result;
HandlerType handler_mode;
filename = fn;
streamname = sn;
is_output = io;
if(is_output) {
flags = O_CREAT|O_TRUNC|O_WRONLY;
} else {
flags = O_RDONLY;
}
remote_fd = REMOTE_CONDOR_open(filename.Value(),(open_flags_t)flags,0777);
if(remote_fd<0) {
dprintf(D_ALWAYS,"Couldn't open %s to stream %s: %s\n",filename.Value(),streamname.Value(),strerror(errno));
return false;
}
// create a DaemonCore pipe
result = daemonCore->Create_Pipe(pipe_fds,
is_output, // registerable for read if it's streamed output
!is_output, // registerable for write if it's streamed input
false, // blocking read
false, // blocking write
STREAM_BUFFER_SIZE);
if(result==0) {
dprintf(D_ALWAYS,"Couldn't create pipe to stream %s: %s\n",streamname.Value(),strerror(errno));
REMOTE_CONDOR_close(remote_fd);
return false;
}
if(is_output) {
job_pipe = pipe_fds[1];
handler_pipe = pipe_fds[0];
handler_mode = HANDLE_READ;
} else {
job_pipe = pipe_fds[0];
handler_pipe = pipe_fds[1];
handler_mode = HANDLE_WRITE;
}
offset = 0;
daemonCore->Register_Pipe(handler_pipe,"Job I/O Pipe",static_cast<PipeHandlercpp>(&StreamHandler::Handler),"Stream I/O Handler",this,handler_mode);
done = false;
connected = true;
handlers[num_handlers++] = this;
return true;
}
void IOProxyHandler::handle_standard_request( ReliSock *r, char *line )
{
char *url = NULL;
char path[CHIRP_LINE_MAX];
char newpath[CHIRP_LINE_MAX];
char flags_string[CHIRP_LINE_MAX];
char name[CHIRP_LINE_MAX];
char expr[CHIRP_LINE_MAX];
int result, offset, whence, length, flags, mode, fd, stride_length;
int stride_skip, uid, gid, actime, modtime;
dprintf(D_SYSCALLS,"IOProxyHandler: request: %s\n",line);
flags_string[0] = 0;
if(m_enable_files && sscanf_chirp(line,"open %s %s %d",path,flags_string,&mode)==3) {
/*
Open is a rather special case.
First, we attempt to look up the file name and
convert it into a physical url. Then, we make
sure that we know how to open the url.
Finally, we actually open it.
*/
dprintf(D_SYSCALLS,"Getting mapping for file %s\n",path);
result = REMOTE_CONDOR_get_file_info_new(path,url);
if(result==0) {
dprintf(D_SYSCALLS,"Directed to use url %s\n",url);
ASSERT( strlen(url) < CHIRP_LINE_MAX );
if(!strncmp(url,"remote:",7)) {
strncpy(path,url+7,CHIRP_LINE_MAX);
} else if(!strncmp(url,"buffer:remote:",14)) {
strncpy(path,url+14,CHIRP_LINE_MAX);
} else {
// Condor 7.9.6 dropped the remote: and buffer:remote prefix for the vanilla shadow
// so it's not longer correct to assert then these prefixes are missing.
// TJ: for some reason get_peer_version() is not set here, so I have to assume that the other side
// *might* be 7.9.6 and tolerate the missing url prefix.
const CondorVersionInfo *vi = r->get_peer_version();
dprintf(D_SYSCALLS | D_VERBOSE,"File %s maps to url %s, peer version is %d.%d.%d\n", path, url,
vi ? vi->getMajorVer() : 0, vi ? vi->getMinorVer() : 0, vi ? vi->getSubMinorVer() : 0);
if (vi && ! vi->built_since_version(7,9,6)) {
EXCEPT("File %s maps to url %s, which I don't know how to open.\n",path,url);
}
strncpy(path,url,CHIRP_LINE_MAX);
}
} else {
EXCEPT("Unable to map file %s to a url: %s\n",path,strerror(errno));
}
dprintf(D_SYSCALLS,"Which simplifies to file %s\n",path);
flags = 0;
if( strchr(flags_string,'w') ) {
if( strchr(flags_string,'r') ) {
flags |= O_RDWR;
} else {
flags |= O_WRONLY;
}
} else {
flags |= O_RDONLY;
}
if(strchr(flags_string,'c')) flags |= O_CREAT;
if(strchr(flags_string,'t')) flags |= O_TRUNC;
if(strchr(flags_string,'x')) flags |= O_EXCL;
if(strchr(flags_string,'a')) flags |= O_APPEND;
result = REMOTE_CONDOR_open(path,(open_flags_t)flags,mode);
sprintf(line,"%d",convert(result,errno));
r->put_line_raw(line);
// Stat stuff
if(result>=0) {
char *buffer = (char*) malloc(1024);
ASSERT( buffer != NULL );
REMOTE_CONDOR_stat(path, buffer);
r->put_bytes_raw(buffer,strlen(buffer));
free( buffer );
}
free( url );
url = NULL;
} else if(m_enable_files && sscanf_chirp(line,"close %d",&fd)==1) {
result = REMOTE_CONDOR_close(fd);
sprintf(line,"%d",convert(result,errno));
r->put_line_raw(line);
} else if(m_enable_files && sscanf_chirp(line,"lseek %d %d %d",&fd,&offset,&whence)) {
int whence_valid = 1;
switch(whence) {
case 0:
whence = SEEK_SET;
break;
case 1:
whence = SEEK_CUR;
break;
case 2:
whence = SEEK_END;
break;
default:
whence_valid = 0;
break;
}
if(whence_valid) {
result = REMOTE_CONDOR_lseek(fd,offset,whence);
result = convert(result,errno);
} else {
result = CHIRP_ERROR_INVALID_REQUEST;
}
sprintf(line,"%d",result);
r->put_line_raw(line);
} else if(m_enable_files && sscanf_chirp(line,"unlink %s",path)==1) {
result = REMOTE_CONDOR_unlink(path);
sprintf(line,"%d",convert(result,errno));
r->put_line_raw(line);
} else if(m_enable_files && sscanf_chirp(line,"rename %s %s",path,newpath)==2) {
result = REMOTE_CONDOR_rename(path,newpath);
sprintf(line,"%d",convert(result,errno));
r->put_line_raw(line);
} else if(m_enable_files && sscanf_chirp(line,"mkdir %s %d",path,&mode)==2) {
result = REMOTE_CONDOR_mkdir(path,mode);
sprintf(line,"%d",convert(result,errno));
r->put_line_raw(line);
} else if(m_enable_files && sscanf_chirp(line,"rmdir %s",path)==1) {
result = REMOTE_CONDOR_rmdir(path);
sprintf(line,"%d",convert(result,errno));
r->put_line_raw(line);
} else if(m_enable_files && sscanf_chirp(line,"fsync %d",&fd)==1) {
result = REMOTE_CONDOR_fsync(fd);
sprintf(line,"%d",convert(result,errno));
r->put_line_raw(line);
} else if(m_enable_files && sscanf_chirp(line,"lookup %s",path)==1) {
result = REMOTE_CONDOR_get_file_info_new(path,url);
if(result==0) {
dprintf(D_SYSCALLS,"Filename %s maps to url %s\n",path,url);
sprintf(line,"%u",(unsigned int)strlen(url));
r->put_line_raw(line);
r->put_bytes_raw(url,strlen(url));
} else {
sprintf(line,"%d",convert(result,errno));
r->put_line_raw(line);
}
free( url );
url = NULL;
} else if(m_enable_delayed && sscanf_chirp(line,"set_job_attr_delayed %s %s",name,expr)==2) {
classad::ClassAdParser parser;
classad::ExprTree *expr_tree;
if (strlen(expr) > 993)
{
dprintf(D_FULLDEBUG, "Chirp update too long! (%lu)\n", strlen(expr));
result = -1;
errno = ENAMETOOLONG;
}
else
{
result = parser.ParseExpression(expr, expr_tree);
if (result)
{
result = !m_shadow->recordDelayedUpdate(name, *expr_tree);
}
else
{
dprintf(D_ALWAYS, "Failed to parse line to a ClassAd expression: %s\n", expr);
}
}
sprintf(line,"%d",convert(result,errno));
r->put_line_raw(line);
} else if(m_enable_updates && sscanf_chirp(line,"set_job_attr %s %s",name,expr)==2) {
result = REMOTE_CONDOR_set_job_attr(name,expr);
sprintf(line,"%d",convert(result,errno));
r->put_line_raw(line);
} else if((m_enable_updates) && sscanf_chirp(line,"get_job_attr %s",name)==1) {
char *recv_expr = NULL;
result = REMOTE_CONDOR_get_job_attr(name,recv_expr);
if(result==0) {
sprintf(line,"%u",(unsigned int)strlen(recv_expr));
r->put_line_raw(line);
r->put_bytes_raw(recv_expr,strlen(recv_expr));
} else {
sprintf(line,"%d",convert(result,errno));
r->put_line_raw(line);
}
free( recv_expr );
} else if(m_enable_delayed && sscanf_chirp(line,"get_job_attr_delayed %s",name)==1) {
std::string value;
classad::ClassAdUnParser unparser;
std::auto_ptr<classad::ExprTree> expr = m_shadow->getDelayedUpdate(name);
if (expr.get()) {
unparser.Unparse(value, expr.get());
sprintf(line,"%u",(unsigned int)value.size());
r->put_line_raw(line);
r->put_bytes_raw(value.c_str(),value.size());
} else {
sprintf(line,"%d",convert(-1,ENOENT));
r->put_line_raw(line);
}
} else if(m_enable_updates && sscanf_chirp(line,"constrain %s",expr)==1) {
result = REMOTE_CONDOR_constrain(expr);
sprintf(line,"%d",convert(result,errno));
r->put_line_raw(line);
} else if(m_enable_files && sscanf_chirp(line,"read %d %d",&fd,&length)==2) {
char *buffer = (char*) malloc(length);
if(buffer) {
result = REMOTE_CONDOR_read(fd,buffer,length);
sprintf(line,"%d",convert(result,errno));
r->put_line_raw(line);
if(result>0) {
r->put_bytes_raw(buffer,result);
}
free(buffer);
} else {
sprintf(line,"%d",CHIRP_ERROR_NO_MEMORY);
}
} else if(m_enable_files && sscanf_chirp(line,"write %d %d",&fd,&length)==2) {
char *buffer = (char*) malloc(length);
if(buffer) {
result = r->get_bytes_raw(buffer,length);
if(result==length) {
result = REMOTE_CONDOR_write(fd,buffer,length);
sprintf(line,"%d",convert(result,errno));
} else {
sprintf(line,"%d",CHIRP_ERROR_INVALID_REQUEST);
}
free(buffer);
} else {
sprintf(line,"%d",CHIRP_ERROR_NO_MEMORY);
}
r->put_line_raw(line);
} else if(m_enable_updates && sscanf_chirp(line,"phase %s", name)==1) {
result = REMOTE_CONDOR_phase( name );
sprintf(line, "%d", convert(result,errno));
r->put_line_raw(line);
} else if(m_enable_updates && sscanf_chirp(line,"ulog %s", name)==1) {
GenericEvent event;
ClassAd *ad;
// setInfoText truncates name to 128 bytes
event.setInfoText( name );
ad = event.toClassAd();
ASSERT(ad);
result = REMOTE_CONDOR_ulog( ad );
sprintf(line, "%d", convert(result,errno));
r->put_line_raw(line);
} else if(m_enable_files && sscanf_chirp(line, "pread %d %d %d", &fd, &length, &offset) == 3){
char *buffer = (char*) malloc(length);
if(buffer) {
result = REMOTE_CONDOR_pread(fd,buffer,length,offset);
sprintf(line,"%d",convert(result,errno));
r->put_line_raw(line);
if(result > 0) {
r->put_bytes_raw(buffer,result);
}
free(buffer);
} else {
sprintf(line,"%d",CHIRP_ERROR_NO_MEMORY);
r->put_line_raw(line);
}
} else if(m_enable_files && sscanf_chirp(line,"pwrite %d %d %d", &fd, &length, &offset) == 3){
char *buffer = (char*) malloc(length);
if(buffer) {
result = r->get_bytes_raw(buffer,length);
if(result == length) {
result = REMOTE_CONDOR_pwrite(fd,buffer,length,offset);
sprintf(line,"%d",convert(result,errno));
} else {
sprintf(line,"%d",CHIRP_ERROR_INVALID_REQUEST);
}
free(buffer);
} else {
sprintf(line,"%d",CHIRP_ERROR_NO_MEMORY);
}
r->put_line_raw(line);
} else if(m_enable_files && sscanf_chirp(line, "sread %d %d %d %d %d", &fd, &length, &offset,
&stride_length, &stride_skip) == 5)
{
char *buffer = (char*) malloc(length);
if(buffer) {
result = REMOTE_CONDOR_sread(fd,buffer,length,offset,
stride_length,stride_skip);
sprintf(line,"%d",convert(result,errno));
r->put_line_raw(line);
if(result > 0) {
r->put_bytes_raw(buffer,result);
}
free(buffer);
} else {
sprintf(line,"%d",CHIRP_ERROR_NO_MEMORY);
r->put_line_raw(line);
}
} else if(m_enable_files && sscanf_chirp(line,"swrite %d %d %d %d %d", &fd, &length, &offset,
&stride_length, &stride_skip) == 5)
{
char *buffer = (char*) malloc(length);
if(buffer) {
result = r->get_bytes_raw(buffer,length);
if(result==length) {
result = REMOTE_CONDOR_swrite(fd,buffer,length,offset,
stride_length,stride_skip);
sprintf(line,"%d",convert(result,errno));
} else {
sprintf(line,"%d",CHIRP_ERROR_INVALID_REQUEST);
}
free(buffer);
} else {
sprintf(line,"%d",CHIRP_ERROR_NO_MEMORY);
}
r->put_line_raw(line);
} else if(m_enable_files && sscanf_chirp(line,"rmall %s", &path) == 1) {
result = REMOTE_CONDOR_rmall(path);
sprintf(line, "%d", convert(result, errno));
r->put_line_raw(line);
} else if(m_enable_files && sscanf_chirp(line,"fstat %d", &fd) == 1) {
char *buffer = (char*) malloc(1024);
if(buffer) {
result = REMOTE_CONDOR_fstat(fd, buffer);
sprintf(line,"%d",convert(result,errno));
r->put_line_raw(line);
if(result>=0) {
r->put_bytes_raw(buffer,strlen(buffer));
}
free(buffer);
} else {
sprintf(line,"%d",CHIRP_ERROR_NO_MEMORY);
r->put_line_raw(line);
}
} else if(m_enable_files && sscanf_chirp(line,"fstatfs %d", &fd) == 1) {
char *buffer = (char*) malloc(1024);
if(buffer) {
result = REMOTE_CONDOR_fstatfs(fd, buffer);
sprintf(line, "%d", convert(result, errno));
r->put_line_raw(line);
if(result>=0) {
r->put_bytes_raw(buffer,strlen(buffer));
}
free(buffer);
} else {
sprintf(line,"%d",CHIRP_ERROR_NO_MEMORY);
r->put_line_raw(line);
}
} else if(m_enable_files && sscanf_chirp(line,"fchown %d %d %d", &fd, &uid, &gid) == 3) {
result = REMOTE_CONDOR_fchown(fd, uid, gid);
sprintf(line, "%d", convert(result, errno));
r->put_line_raw(line);
} else if(m_enable_files && sscanf_chirp(line,"fchmod %d %d", &fd, &mode) == 2) {
result = REMOTE_CONDOR_fchmod(fd, mode);
sprintf(line, "%d", convert(result, errno));
r->put_line_raw(line);
} else if(m_enable_files && sscanf_chirp(line,"ftruncate %d %d", &fd, &length) == 2) {
result = REMOTE_CONDOR_ftruncate(fd, length);
sprintf(line, "%d", convert(result, errno));
r->put_line_raw(line);
} else if(m_enable_files && sscanf_chirp(line,"getfile %s", &path) == 1) {
char *buffer = NULL;
result = REMOTE_CONDOR_getfile(path, &buffer);
sprintf(line,"%d",convert(result,errno));
r->put_line_raw(line);
if(result > 0) {
r->put_bytes_raw(buffer,result);
free(buffer);
}
} else if(m_enable_files && sscanf_chirp(line,"putfile %s %d %d", &path, &mode, &length) == 3)
{
// First check if putfile is possible
result = REMOTE_CONDOR_putfile(path, mode, length);
sprintf(line, "%d", convert(result, errno));
r->put_line_raw(line);
if ((length > 0) && (result >= 0)) {
char *buffer = (char*) malloc(length);
if(buffer) {
result = r->get_bytes_raw(buffer,length);
// Now actually putfile
result = REMOTE_CONDOR_putfile_buffer(buffer, length);
sprintf(line, "%d", convert(result, errno));
r->put_line_raw(line);
} else {
sprintf(line,"%d",CHIRP_ERROR_NO_MEMORY);
r->put_line_raw(line);
}
}
} else if(m_enable_files && sscanf_chirp(line,"getlongdir %s", &path) == 1) {
char *buffer = NULL;
result = REMOTE_CONDOR_getlongdir(path, buffer);
sprintf(line, "%d", convert(result, errno));
r->put_line_raw(line);
if(result>0) {
r->put_bytes_raw(buffer,strlen(buffer));
}
} else if(m_enable_files && sscanf_chirp(line,"getdir %s", &path) == 1) {
char *buffer = NULL;
result = REMOTE_CONDOR_getdir(path, buffer);
sprintf(line, "%d", convert(result, errno));
r->put_line_raw(line);
if(result>0) {
r->put_bytes_raw(buffer,strlen(buffer));
}
} else if(m_enable_files && sscanf_chirp(line,"whoami %d", &length) == 1) {
char *buffer = (char*)malloc(length);
if(buffer) {
result = REMOTE_CONDOR_whoami(length, buffer);
sprintf(line, "%d", convert(result, errno));
r->put_line_raw(line);
if(result>0) {
r->put_bytes_raw(buffer,result);
}
free(buffer);
} else {
sprintf(line,"%d",CHIRP_ERROR_NO_MEMORY);
r->put_line_raw(line);
}
} else if(m_enable_files && sscanf_chirp(line,"whoareyou %s %d", &path, &length) == 2) {
char *buffer = (char*)malloc(length);
if(buffer) {
result = REMOTE_CONDOR_whoareyou(path, length, buffer);
sprintf(line, "%d", convert(result, errno));
r->put_line_raw(line);
if(result>0) {
r->put_bytes_raw(buffer,result);
}
free(buffer);
} else {
sprintf(line,"%d",CHIRP_ERROR_NO_MEMORY);
r->put_line_raw(line);
}
} else if(m_enable_files && sscanf_chirp(line,"link %s %s", &path, &newpath) == 2) {
result = REMOTE_CONDOR_link(path, newpath);
sprintf(line, "%d", convert(result, errno));
r->put_line_raw(line);
} else if(m_enable_files && sscanf_chirp(line,"symlink %s %s", &path, &newpath) == 2) {
result = REMOTE_CONDOR_symlink(path, newpath);
sprintf(line, "%d", convert(result, errno));
r->put_line_raw(line);
} else if(m_enable_files && sscanf_chirp(line,"readlink %s %d", &path, &length) == 2) {
char *buffer = NULL;
result = REMOTE_CONDOR_readlink(path, length, &buffer);
sprintf(line, "%d", convert(result, errno));
r->put_line_raw(line);
if(result>0) {
r->put_bytes_raw(buffer,result);
free(buffer);
}
} else if(m_enable_files && sscanf_chirp(line,"statfs %s", &path) == 1) {
char *buffer = (char*) malloc(1024);
if(buffer) {
result = REMOTE_CONDOR_statfs(path, buffer);
sprintf(line, "%d", convert(result, errno));
r->put_line_raw(line);
if(result>=0) {
r->put_bytes_raw(buffer,strlen(buffer));
}
free(buffer);
} else {
sprintf(line,"%d",CHIRP_ERROR_NO_MEMORY);
r->put_line_raw(line);
}
} else if(m_enable_files && sscanf_chirp(line,"stat %s", &path) == 1) {
char *buffer = (char*) malloc(1024);
if(buffer) {
result = REMOTE_CONDOR_stat(path, buffer);
sprintf(line, "%d", convert(result, errno));
r->put_line_raw(line);
if(result==0) {
r->put_bytes_raw(buffer,strlen(buffer));
}
free(buffer);
} else {
sprintf(line,"%d",CHIRP_ERROR_NO_MEMORY);
r->put_line_raw(line);
}
} else if(m_enable_files && sscanf_chirp(line,"lstat %s", &path) == 1) {
char *buffer = (char*) malloc(1024);
if(buffer) {
result = REMOTE_CONDOR_lstat(path, buffer);
sprintf(line, "%d", convert(result, errno));
r->put_line_raw(line);
if(result>=0) {
r->put_bytes_raw(buffer,strlen(buffer));
}
free(buffer);
} else {
sprintf(line,"%d",CHIRP_ERROR_NO_MEMORY);
r->put_line_raw(line);
}
} else if(m_enable_files && sscanf_chirp(line,"access %s %d", &path, &mode) == 2) {
result = REMOTE_CONDOR_access(path, mode);
sprintf(line, "%d", convert(result, errno));
r->put_line_raw(line);
} else if(m_enable_files && sscanf_chirp(line,"chmod %s %d", &path, &mode) == 2) {
result = REMOTE_CONDOR_chmod(path, mode);
sprintf(line, "%d", convert(result, errno));
r->put_line_raw(line);
} else if(m_enable_files && sscanf_chirp(line,"chown %s %d %d", &path, &uid, &gid) == 3) {
result = REMOTE_CONDOR_chown(path, uid, gid);
sprintf(line, "%d", convert(result, errno));
r->put_line_raw(line);
} else if(m_enable_files && sscanf_chirp(line,"lchown %s %d %d", &path, &uid, &gid) == 3) {
result = REMOTE_CONDOR_lchown(path, uid, gid);
sprintf(line, "%d", convert(result, errno));
r->put_line_raw(line);
} else if(m_enable_files && sscanf_chirp(line,"truncate %s %d", &path, &length) == 2) {
result = REMOTE_CONDOR_truncate(path, length);
sprintf(line, "%d", convert(result, errno));
r->put_line_raw(line);
} else if(m_enable_files && sscanf_chirp(line,"utime %s %d %d", &path, &actime, &modtime) == 3){
result = REMOTE_CONDOR_utime(path, actime, modtime);
sprintf(line, "%d", convert(result, errno));
r->put_line_raw(line);
} else if(m_enable_updates && strncmp(line,"version",7)==0) {
sprintf(line,"%d",CHIRP_VERSION);
r->put_line_raw(line);
}
else {
sprintf(line,"%d",CHIRP_ERROR_INVALID_REQUEST);
r->put_line_raw(line);
}
dprintf(D_SYSCALLS,"IOProxyHandler: response: %s\n",line);
}
bool StreamHandler::Init( const char *fn, const char *sn, bool io, int f )
{
int result;
HandlerType handler_mode;
filename = fn;
streamname = sn;
is_output = io;
flags = f;
if( flags == -1 ) {
if( is_output ) {
flags = O_CREAT | O_TRUNC | O_WRONLY;
} else {
flags = O_RDONLY;
}
}
bool shouldAppend = false;
if( flags & O_APPEND ) {
// If we actually pass O_APPEND, then when we reconnect, flushing the
// buffer will result in duplicate data if the far side suffered a
// partial write. (If it failed to write the buffer at all, that's
// OK, because we /wanted/ to append it to the file.)
//
// Instead, unset O_APPEND and simulate the effect: seek to the end of
// the file on open and set offset to that.
shouldAppend = true;
flags = flags & (~O_APPEND);
}
remote_fd = REMOTE_CONDOR_open(filename.Value(),(open_flags_t)flags,0777);
if(remote_fd<0) {
dprintf(D_ALWAYS,"Couldn't open %s to stream %s: %s\n",filename.Value(),streamname.Value(),strerror(errno));
return false;
}
offset = 0;
if( shouldAppend ) {
offset = REMOTE_CONDOR_lseek( remote_fd, 0, SEEK_END );
if( offset < 0 ) {
dprintf( D_ALWAYS, "Couldn't seek to end of %s for stream %s when append mode was requested: %s\n", filename.Value(), streamname.Value(), strerror( errno ) );
return false;
}
dprintf( D_SYSCALLS, "StreamHandler: Sought to %ld as a result of append request.\n", (long)offset );
}
// create a DaemonCore pipe
result = daemonCore->Create_Pipe(pipe_fds,
is_output, // registerable for read if it's streamed output
!is_output, // registerable for write if it's streamed input
false, // blocking read
false, // blocking write
STREAM_BUFFER_SIZE);
if(result==0) {
dprintf(D_ALWAYS,"Couldn't create pipe to stream %s: %s\n",streamname.Value(),strerror(errno));
REMOTE_CONDOR_close(remote_fd);
return false;
}
if(is_output) {
job_pipe = pipe_fds[1];
handler_pipe = pipe_fds[0];
handler_mode = HANDLE_READ;
} else {
job_pipe = pipe_fds[0];
handler_pipe = pipe_fds[1];
handler_mode = HANDLE_WRITE;
}
daemonCore->Register_Pipe(handler_pipe,"Job I/O Pipe",static_cast<PipeHandlercpp>(&StreamHandler::Handler),"Stream I/O Handler",this,handler_mode);
done = false;
connected = true;
handlers.push_back( this );
return true;
}
