virtual int process (Message *message)
{
ACE_TRACE ("SaveMetaData::process()");
ACE_TString path (message->addr ().get_path_name ());
path += ACE_TEXT (".xml");
ACE_FILE_Connector connector;
ACE_FILE_IO file;
ACE_FILE_Addr addr (path.c_str ());
if (connector.connect (file, addr) == -1)
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("%p\n"),
ACE_TEXT ("create meta-data file")),
0);
file.truncate (0);
this->write (file, "<Message>\n");
// ...
this->write (file, "</Message>\n");
file.close ();
return 0;
}
static int
test_ostream (void)
{
// This message should show up in the log file.
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("first message\n")));
ACE_LOG_MSG->clr_flags (ACE_Log_Msg::OSTREAM);
// This message should not show up anywhere.
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("second message\n")));
ACE_LOG_MSG->set_flags (ACE_Log_Msg::OSTREAM);
#if !defined (ACE_LACKS_IOSTREAM_TOTALLY)
// Create a persistent store.
const ACE_TCHAR *filename = ACE_TEXT ("output");
ofstream myostream (ACE_TEXT_ALWAYS_CHAR (filename), ios::out | ios::trunc);
// Check for errors.
if (myostream.bad ())
return -1;
OFSTREAM *old_stream = ace_file_stream::instance ()->output_file ();
// Set the ostream.
ACE_LOG_MSG->msg_ostream (&myostream);
// This message should show up in the ostream.
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("fourth message\n")));
// Set the ostream back to the test's log file.
ACE_LOG_MSG->msg_ostream (old_stream);
// Now close the ostream file and check its contents.
myostream.close ();
ACE_FILE_Connector connector;
ACE_FILE_IO file;
ACE_FILE_Addr file_addr (filename);
// Open up the file.
if (connector.connect (file, file_addr) == -1)
{
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("connect failed for %p\n"),
filename),
1);
}
#if !defined (ACE_VXWORKS) && !defined (ACE_HAS_PHARLAP) || (defined(ACE_VXWORKS) && (ACE_VXWORKS > 0x690))
# define TEST_CAN_UNLINK_IN_ADVANCE
#endif
#if defined (TEST_CAN_UNLINK_IN_ADVANCE)
// Unlink this file right away so that it is automatically removed
// when the process exits.Ignore error returns in case this operation
// is not supported.
ACE_OS::unlink(filename);
#endif
ACE_FILE_Info info;
if (file.get_info (info) == -1)
{
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("get_info failed on %p\n"),
filename),
-1);
}
// Allocate the input buffer
char *buffer = 0;
ACE_NEW_RETURN (buffer,
char[info.size_ + 1],
-1);
// Make sure <buffer> is released automagically.
ACE_Auto_Basic_Array_Ptr<char> b (buffer);
// Read the file into the buffer.
ssize_t size = file.recv (buffer,
info.size_);
if (size != info.size_)
{
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("Read %d bytes, rather than expected %d bytes\n"),
size,
info.size_),
-1);
}
// Make sure to NUL-terminate this turkey!
buffer[size] = '\0';
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("%C"),
buffer));
#if !defined (TEST_CAN_UNLINK_IN_ADVANCE)
file.close ();
if (file.unlink () == -1)
ACE_ERROR_RETURN ((LM_ERROR,
ACE_TEXT ("unlink failed for %p\n"),
file_addr.get_path_name ()),
1);
#endif
#endif /* ACE_LACKS_IOSTREAM_TOTALLY */
// This message should show up in stderr and the ostream (without
// ACE_LACKS_IOSTREAM_TOTALLY).
ACE_DEBUG ((LM_DEBUG,
ACE_TEXT ("fifth message\n")));
return 0;
}
void
JAWS_Config_File_Impl::parse_file (void)
{
ACE_FILE_Connector fconnector;
ACE_FILE_IO fio;
if (fconnector.connect ( fio
, this->faddr_
, 0
, ACE_Addr::sap_any
, 0
, O_RDONLY
) == -1)
return;
ACE_Message_Block buffer (8192);
ACE_Message_Block line (4096);
ssize_t count = 0;
const ACE_TCHAR *sym_name;
const ACE_TCHAR *sym_value;
int last_line_was_read = 0;
ACE_TCHAR *end_of_current_line = 0;
ACE_TCHAR *p = 0;
while (last_line_was_read
|| (count = fio.recv (buffer.wr_ptr (), buffer.space () - 2)) >= 0)
{
end_of_current_line = 0;
// Make sure input is newline terminated if it is the last line,
// and always null terminated.
if (! last_line_was_read)
{
if (count > 0)
{
buffer.wr_ptr (count);
// Scan forward for at least one newline character
p = buffer.rd_ptr ();
while (p != buffer.wr_ptr ())
{
if (*p == '\n')
break;
p++;
}
if (p == buffer.wr_ptr ())
continue;
end_of_current_line = p;
}
else
{
if (buffer.wr_ptr ()[-1] != '\n')
{
buffer.wr_ptr ()[0] = '\n';
buffer.wr_ptr (1);
}
last_line_was_read = 1;
}
buffer.wr_ptr ()[0] = '\0';
}
if (end_of_current_line == 0)
{
end_of_current_line = buffer.rd_ptr ();
while (*end_of_current_line != '\n')
end_of_current_line++;
}
// If buffer is not pointing to a continuation line, or there is
// no more input, then can commit the scanned configuration
// line.
if (line.length () != 0
&& ((last_line_was_read && buffer.length () == 0)
|| (buffer.rd_ptr ()[0] != ' '
&& buffer.rd_ptr ()[0] != '\t')))
{
ACE_TCHAR *name = 0;
ACE_TCHAR *value = 0;
name = line.rd_ptr ();
for (p = name; *p != '\0'; p++)
{
if (*p == '=')
{
line.rd_ptr (p+1);
while (p != name && (p[-1] == ' ' || p[-1] == '\t'))
p--;
*p = '\0';
}
}
if (*name)
{
value = line.rd_ptr ();
while (*value == ' ' || *value == '\t')
value++;
p = line.wr_ptr ();
while (p != value && (p[-1] == ' ' || p[-1] == '\t'))
p--;
*p = '\0';
sym_name = this->strings_->duplicate (name);
sym_value = this->strings_->duplicate (value);
this->symbols_->rebind (sym_name, sym_value);
}
line.reset ();
}
// If we are done, we are done!
if (last_line_was_read && buffer.length () == 0)
break;
// If the buffer is pointing at a comment line, ignore it.
if (buffer.rd_ptr ()[0] == '#'
|| buffer.rd_ptr ()[0] == '\n'
|| (buffer.rd_ptr ()[0] == '\r' && buffer.rd_ptr ()[1] == '\n'))
{
buffer.rd_ptr (end_of_current_line + 1);
buffer.crunch ();
continue;
}
// Whatever is left is either the start of a name-value-pair or a
// continuation of one.
line.copy (buffer.rd_ptr (),
end_of_current_line - buffer.rd_ptr ());
p = line.wr_ptr ();
while (p != line.rd_ptr () && (p[-1] == ' ' || p[-1] == '\t'))
p--;
line.wr_ptr (p);
line.wr_ptr ()[0] = '\0';
buffer.rd_ptr (end_of_current_line + 1);
buffer.crunch ();
}
fio.close ();
}
int FileIOHandler::Connect()
{
int result = 0;
// create an empty temporary file for the test
if(connector_.connect(peer_,
ACE_sap_any_cast (ACE_FILE_Addr &)) != 0)
{
ACE_ERROR((LM_ERROR, ACE_TEXT("%p\n"),
ACE_TEXT("FileIOHandler connect failed to create file")));
result = -1;
}
// close opened file but leave it where it is
if (peer_.close () != 0)
{
ACE_ERROR((LM_ERROR, ACE_TEXT("%p\n"),
ACE_TEXT("FileIOHandler connect failed to close file")));
peer_.remove ();
result = -1;
}
// get file address
ACE_FILE_Addr tmp_addr;
peer_.get_local_addr (tmp_addr);
// reopen new file for asynch IO
if(connector_.connect(peer_,
tmp_addr,
0, //timeout
ACE_Addr::sap_any,
0, //reuse
O_RDWR |FILE_FLAG_OVERLAPPED) != 0)
{
ACE_ERROR((LM_ERROR, ACE_TEXT("%p\n"),
ACE_TEXT("FileIOHandler connect failed to open file")));
peer_.remove ();
result = -1;
}
else // device connected successfully
{
// keep track of our writes for offset calculations (can't use O_APPEND since
// this is not supported for the Win32_Asynch implementation) and data verifications
this->block_count_ = 0; // start counting
// Set our I/O handle to that of the peer_ object handling our connection
handle(peer_.get_handle());
if (writer_.open(*this) != 0 || reader_.open(*this) != 0)
{
ACE_ERROR(
(LM_ERROR, ACE_TEXT("%p\n"), ACE_TEXT("FileIOHandler reader or writer open failed")));
result = -1;
}
else // reader and writer opened successfully
{
// Allocate a new message block and initiate a read operation on it
// to prime the asynchronous read pipeline
// The message block is sized for the largest message we expect
ACE_Message_Block *mb;
ACE_NEW_NORETURN(mb, ACE_Message_Block(FILE_FRAME_SIZE));
if (reader_.read(*mb, mb->space()) != 0)
{
int errnr = ACE_OS::last_error ();
ACE_DEBUG(
(LM_INFO, ACE_TEXT("%p [%d]\n"), ACE_TEXT("FileIOHandler begin read failed"), errnr));
mb->release();
#if defined (ACE_WIN32)
// On older Win32 versions (WinXP, Win2003/2008) asynch IO with disk files is not
// reliable and may perform sync IO in certain cases like when the read offset denotes
// current end of file. Instead of scheduling a write operation the read will immediately
// return with an EOF error.
// We circumvent that situation here by not reporting an error and scheduling a read operation
// later when we are sure data has been written at the offset in question (after the write finishes).
if (errnr != ERROR_HANDLE_EOF)
#endif
result = -1;
}
#if defined (ACE_WIN32)
else
{
this->read_pending_ = true;
}
#endif
// If read worked, psMsg is now controlled by Proactor framework.
}
}
return result;
}