NCBI C++ Toolkit Cross Reference

   /*  $Id: named_pipe.cpp 14515 2007-05-04 17:18:18Z kazimird $
    * ===========================================================================
    *
    *                            PUBLIC DOMAIN NOTICE
    *               National Center for Biotechnology Information
    *
    *  This software/database is a "United States Government Work" under the
    *  terms of the United States Copyright Act.  It was written as part of
    *  the author's official duties as a United States Government employee and
   *  thus cannot be copyrighted.  This software/database is freely available
   *  to the public for use. The National Library of Medicine and the U.S.
   *  Government have not placed any restriction on its use or reproduction.
   *
   *  Although all reasonable efforts have been taken to ensure the accuracy
   *  and reliability of the software and data, the NLM and the U.S.
   *  Government do not and cannot warrant the performance or results that
   *  may be obtained by using this software or data. The NLM and the U.S.
   *  Government disclaim all warranties, express or implied, including
   *  warranties of performance, merchantability or fitness for any particular
   *  purpose.
   *
   *  Please cite the author in any work or product based on this material.
   *
   * ===========================================================================
   *
   * Authors:  Josh Cherry
   *
   * File Description:
   *    Named pipe functionality for Genome Workbench
   */
  
  #include <ncbi_pch.hpp>
  
  #include    <corelib/ncbiapp.hpp>
  
  #include "named_pipe.hpp"
  #include "load_file.hpp"
  
  #include <gui/utils/system_path.hpp>
  
  #include <FL/Fl.H>
  
  
  BEGIN_NCBI_SCOPE
  
  
  CNamedPipeServer CGBenchPipe::sm_NamedPipeServer;
  bool CGBenchPipe::sm_IsOpen;
  CGBenchPipe::FRaiseCallback CGBenchPipe::sm_RaiseCallback = NULL;
  
  void CGBenchPipe::InstallRaiseCallback(FRaiseCallback callback)
  {
      sm_RaiseCallback = callback;
  }
  
  
  void CGBenchPipe::Start(void)
  {
      sm_IsOpen = false;
      if (sm_NamedPipeServer.Create(x_GetPipeName()) != eIO_Success) {
          throw runtime_error("CNamedPipeServer::Create failed");
      }
  
      // zero timeouts for open (Listen) and read
      STimeout to = {0, 0};
      if (sm_NamedPipeServer.SetTimeout(eIO_Open, &to) != eIO_Success) {
          throw runtime_error("CNamedPipeServer::SetTimeout failed for Open");
      }
      if (sm_NamedPipeServer.SetTimeout(eIO_Read, &to) != eIO_Success) {
          throw runtime_error("CNamedPipeServer::SetTimeout failed for Read");
      }
      sm_IsOpen = true;
  }
  
  
  // Determine appropriate name of pipe
  string CGBenchPipe::x_GetPipeName(void)
  {
  #ifdef NCBI_OS_MSWIN
      string user_name = CNcbiApplication::Instance()->GetEnvironment().Get("USERNAME");
      return "\\\\.\\pipe\\gbench_pipe-" + user_name;
  #else  // unix of some sort
      return CSystemPath::ResolvePath("<home>/gbench_pipe");
  #endif
  }
  
  
  // fltk timeout callback to read pipe.
  // ptr argument is a pointer to the app.
  void CGBenchPipe::Process()
  {
      CNamedPipeServer& srv = sm_NamedPipeServer;
      if (!sm_IsOpen) {
          // pipe is not open; don't try to listen
          return;
      }
      if (srv.Listen() == eIO_Success) {
          string data;
          const size_t buf_size = 1024;
         char buf[buf_size];
         size_t n_read;
         while (srv.Status(eIO_Read) == eIO_Success ||
                srv.Status(eIO_Read) == eIO_Timeout) {
             srv.Read(buf, buf_size, &n_read);
             data.append(buf, n_read);
         }
 
         // data is either just a file name, or a file name
         // and a file type separated by a null
         string fname;
         string ftype;
 
         vector<string> tokens;
         string delim;
         delim = '\0';  // not an empty string
         NStr::Tokenize (data, delim, tokens);
         fname = tokens[0];
         if (tokens.size() > 1) {
             ftype = tokens[1];
         } else {
             ftype = "auto";
         }
 
         // a "file" of type "seqid" is really an accession
         if (ftype == "seqid") {
             GBenchLoadAccession(fname);
         } else {
             GBenchLoadFile(fname, ftype);
         }
 
         if(sm_RaiseCallback)    {
             (*sm_RaiseCallback)();
         }
     }
 }
 
 
 void CGBenchPipe::OpenRemote(const string& fname, const string& ftype)
 {
     size_t n_written;
     size_t total_written = 0;
 
     string msg = fname + '\0' + ftype;
 
     CNamedPipeClient cli;
 
     STimeout to = {1, 0};
     if (cli.SetTimeout(eIO_Open, &to) != eIO_Success) {
         throw runtime_error("CNamedPipeServer::SetTimeout failed for Open");
     }
 
     if (cli.Open(x_GetPipeName()) != eIO_Success) {
         throw runtime_error("Failed to open named pipe for writing");
     }
 
     while (1) {
         EIO_Status status = cli.Write(msg.data() + total_written,
                                       msg.size() - total_written, &n_written);
         total_written += n_written;
         if (total_written == msg.size()) {
             break;
         }
         if (status != eIO_Success && status != eIO_Timeout) {
             break;
         }
     }
     if (total_written != msg.size()) {
         throw runtime_error("Failed to write to named pipe");
     }
 }
 
 
 END_NCBI_SCOPE