RecallReportPacker.hpp 4.49 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
/******************************************************************************
 *                      RecallReportPacker.hpp
 *
 * This file is part of the Castor project.
 * See http://castor.web.cern.ch/castor
 *
 * Copyright (C) 2003  CERN
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 *
 * 
 *
 * @author Castor Dev team, castor-dev@cern.ch
 *****************************************************************************/

#ifndef RECALLREPORTPACKER_HPP
#define	RECALLREPORTPACKER_HPP

#include "castor/tape/tapeserver/daemon/ReportPackerInterface.hpp"
#include "castor/log/LogContext.hpp"
30
#include "castor/tape/tapeserver/client/ClientInterface.hpp"
31
32
33
34
35
36
37
38
39
40
#include "castor/tape/tapeserver/threading/Threading.hpp"
#include "castor/tape/tapeserver/threading/BlockingQueue.hpp"

namespace castor {
namespace tape {
namespace tapeserver {
namespace daemon {
  
class RecallReportPacker : private ReportPackerInterface<detail::Recall> {
public:
41
  RecallReportPacker(client::ClientInterface & tg,unsigned int reportFilePeriod,log::LogContext lc);
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
  
  ~RecallReportPacker();
  
  /**
   * Create into the MigrationReportPacker a report for the successful migration
   * of migratedFile
   * @param migratedFile the file successfully migrated
   */
  void reportCompletedJob(const tapegateway::FileToRecallStruct& recalledFile);
  
  /**
   * Create into the MigrationReportPacker a report for the failled migration
   * of migratedFile
   * @param migratedFile the file which failled 
   */
  void reportFailedJob(const tapegateway::FileToRecallStruct & recalledFile,const std::string& msg,int error_code);
       
  /**
   * Create into the MigrationReportPacker a report for the nominal end of session
   */
  void reportEndOfSession();
  
  /**
   * Create into the MigrationReportPacker a report for an erroneous end of session
   * @param msg The error message 
   * @param error_code The error code given by the drive
   */
  void reportEndOfSessionWithErrors(const std::string msg,int error_code);
  
71
72
  void startThreads() { m_workerThread.start(); }
  void waitThread() { m_workerThread.wait(); }
73
74
75
  
private:
  class Report {
76
    const bool m_endNear;
77
  public:
78
    Report(bool b):m_endNear(b){}
79
80
    virtual ~Report(){}
    virtual void execute(RecallReportPacker& packer)=0;
81
    bool goingToEnd() const {return m_endNear;};
82
83
84
85
86
  };
  class ReportSuccessful :  public Report {
    const FileStruct m_migratedFile;
  public:
    ReportSuccessful(const FileStruct& file): 
87
    Report(false),m_migratedFile(file){}
88
89
90
91
92
93
94
95
    virtual void execute(RecallReportPacker& _this);
  };
  class ReportError : public Report {
    const FileStruct m_migratedFile;
    const std::string m_error_msg;
    const int m_error_code;
  public:
    ReportError(const FileStruct& file,std::string msg,int error_code):
96
    Report(false),m_migratedFile(file),m_error_msg(msg),m_error_code(error_code){}
97
98
99
100
101
    
    virtual void execute(RecallReportPacker& _this);
  };
  class ReportEndofSession : public Report {
  public:
102
    ReportEndofSession():Report(false){}
103
104
105
106
107
108
109
    virtual void execute(RecallReportPacker& _this);
  };
  class ReportEndofSessionWithErrors : public Report {
    std::string m_message;
    int m_error_code;
  public:
    ReportEndofSessionWithErrors(std::string msg,int error_code):
110
    Report(false),m_message(msg),m_error_code(error_code){}
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

    virtual void execute(RecallReportPacker& _this);
  };
  
  class WorkerThread: public castor::tape::threading::Thread {
    RecallReportPacker & m_parent;
  public:
    WorkerThread(RecallReportPacker& parent);
    virtual void run();
  } m_workerThread;
  
  void flush();
  
  castor::tape::threading::Mutex m_producterProtection;
  
  /** 
   * m_fifo is holding all the report waiting to be processed
   */
  castor::tape::threading::BlockingQueue<Report*> m_fifo;
  
  unsigned int m_reportFilePeriod;
  bool m_errorHappened;
  bool m_continue;
};

}}}}

#endif	/* RECALLREPORTPACKER_HPP */