ngcdcsMERGE.hpp

Go to the documentation of this file.

#ifndef ngcdcsMERGE_H
#define ngcdcsMERGE_H
 
 
#ifndef __cplusplus
#error This is a C++ include file and cannot be used from plain C
#endif
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
 
#include <ngc/core/ngcb.h>
#include <ngc/core/ngcbSocket.h>
#include <ngc/core/ngcdcsMRGSHM.hpp>

#define ngcdcsMERGE_CHUNK (1024 * 64)

#define ngcdcsMERGE_MAX_FILESIZE (2147483647 - ngcbFITS_BLOCK_LEN)
 
/* ---- just for test
#define ngcdcsMERGE_MAX_FILESIZE ((1024 * 1024 * 2 * 5)  - ngcbFITS_BLOCK_LEN)
---- */

struct ngcdcs_merge_t {
  size_t hdrSize;

  int bitPix;

  int naxis1;

  int naxis2;

  int naxis3;

  int divisor;
  
  double bzero;

  int ftype;
  
  char expId[64];

  char fname[84];
  
  unsigned int chunkSize;

  int cube2Ext;

  int single;

  ngcdcs_merge_t() {
    Clear();
    chunkSize = ngcdcsMERGE_CHUNK;
  }

  void Clear() {
    hdrSize = 0;
    naxis1 = 0;
    naxis2 = 0;
    naxis3 = -1;  // not set
    bitPix = 8;
    divisor = 1;
    bzero = 0.0;
    ftype = 0;    // unresolved
    expId[0] = '\0';
    fname[0] = '\0';
    cube2Ext = 0;
    single = 0;
  }
  
  size_t FrameSize() {
    return ((size_t)(abs(bitPix) / 8) * (size_t)naxis1 * (size_t)naxis2);
  }
};

struct ngcdcs_ns_t {
  FILE *stream;

  int level;

  ngcdcs_ns_t() {
    stream = NULL;
    level = 1;
  }
};
 

class ngcdcsMERGE
{
public:
  int cleanup;

  int verify;

  int invalidate;

  unsigned int chunkSize;

  int parStream;

  int largeFile;

  char targetName[512];

  char listItem[512];

  int verboseLevel;
     
  int logLevel;

  ngcdcsMERGE();

  explicit ngcdcsMERGE(void (*signalHandler)(int));

  virtual ~ngcdcsMERGE();

  int Initialized() {return (initialized_);}

  int BigEndian();

  void Id(int val) {id_ = val;}

  int Id() {return (id_);}

  char *ErrMsg() {return (erms_);}

  int Run(int argc, char **argv);

  void ExitSignal(int sig);

  int Check(const char *name);

  int Process(const char *name, int process=1);

  int ProcessList(FILE *fd, const char *item=NULL);

  int ProcessList(const char *fileName, const char *item=NULL);

  int DeleteList(const char *fileName);

  int DeleteList(FILE *fd);

  int ProcessHdr(const char *fileName);

  int ProcessFits(const char *source, const char *target=NULL);

  int DeleteFits(const char *source);

  int VerifyList(const char *fileName);

  int VerifyHdr(const char *fileName);

  int VerifyFits(const char *source, const char *target=NULL);
  
  double Size() {return (vsize_);}

  int NotificationStream(FILE *stream, int level=1);

  void NotifySize(double size);

  int Aborted() {return (aborted_);}

  const char *Stat2Str(int stat);

  void AttachDisplay();

  void WaitForDisplay();

  void Status(int stat);

  void Completed(int stat, const char *msg=NULL);
 
protected:
  void Initialized(int flag) {initialized_ = flag;}

  virtual int Args(int argc, char **argv);

  virtual FILE *Usage();

  virtual int InitCB();

  virtual void StatusCB(int stat);

  virtual void CompletedCB(int stat, const char *msg=NULL);

  virtual void Notify(double size);

  virtual void FileEvent(const char *id, const char *fileName);

  virtual void NotifySizeCB(double size);

  virtual int CheckPoint();
 
  // Verbose message if verbose level exceeds level
  virtual void Verbose(int level, const char *format, ...)
    __attribute__ ((format(printf, 3, 4)));

  virtual void Verbose(const char *format, ...)
    __attribute__ ((format(printf, 2, 3)));

  virtual void Log(int level, const char *format, ...)
    __attribute__ ((format(printf, 3, 4)));

  virtual void Log(const char *format, ...)
    __attribute__ ((format(printf, 2, 3)));
 
private:
  void (*signalHandler_)(int);

  int initialized_;

  int endian_;

  int id_;

  char erms_[256];

  char statDisp_[32];

  void Init_();

  void Usage_(FILE *stream);

  void Cleanup_(char *s);

  void CardReset_(char *line);

  int ProcessList_(FILE *fd, const char *fileName, const char *item=NULL);

  int DeleteList_(FILE *fd, const char *fileName);

  char *Where_(char *buf, const char *key);

  int GetKey_(char *buf, const char *key, int *value);

  int GetKey_(char *buf, const char *key, double *value);

  int GetKey_(char *buf, const char *key, char *value);

  int SetKey_(char *buf, const char *fitsLine);

  char *RdFitsLine_(FILE *fd);

  int UpdateFitsLine_(FILE *fd, ngcb_off_t pos, const char *line);

  int verificationRun_;

  int justVerify_;

  double vsize_;

  double tsize_;
  
  ngcdcs_ns_t ns_[4];
  
  int numNs_;

  int notifyLinkStat_;

  void Notify_(double size);

  void FileEventStart_(const char *fileName);

  void FileEvent_(const char *id, const char *fileName);

  int CheckPoint_();

  int aborted_;

  ngcb_pipe_t statPipe_;

  int statDispClose_;

  char statStr_[32];

  int srvSocket_;

  FILE *statusStream_;

  int ServerMode_(int execHandle);
 
  // Check if file descriptor has an event pending
  int CheckFd_(int fd);

  char thisHost_[64];

  char padBlock_[ngcbFITS_BLOCK_LEN];       

  char fitsLine_[ngcbFITS_LINE_LEN + 1];       

  void ScaleReal32_(float *buf, int scale, size_t size);

  void ScaleInt32_(int *buf, int scale, size_t size);

  void ScaleInt16_(short *buf, int scale, size_t size);

  void ScaleUInt16_(unsigned short *buf, int scale, size_t size);

  void Scale_(char *buf, size_t size, int bitPix, int divisor);

  char *AllocHdr_(const char *fileName, ngcdcs_merge_t *minfo);

  int Copy_(FILE *fdOut, const char *host, const char *fileName, 
        ngcdcs_merge_t *minfo);

  ngcdcsMRGSHM *shm_;

  int ignoreFormat_;

  int slow_;
};
 
#endif