← Back to branch summary

~ubuntu-branches/ubuntu/wily/trafficserver/wily

« back to all changes in this revision

Viewing changes to proxy/logging/LogObject.h

  • Committer: Package Import Robot
  • Author(s): Adam Conrad
  • Date: 2012-12-17 22:28:16 UTC
  • mfrom: (5.1.8 raring-proposed)
  • Revision ID: package-import@ubuntu.com-20121217222816-7xwjsx5k76zkb63d
Tags: 3.2.0-1ubuntu1
* Revert FreeBSD strerror_r() fixes that give errors with glibc 2.16.
* Apply patch from Konstantinos Margaritis to define barriers on ARM.

Show diffs side-by-side

added added

removed removed

Lines of Context:
proxy/logging/LogObject.h
54
54
#define ASCII_PIPE_OBJECT_FILENAME_EXTENSION ".pipe"
55
55
 
56
56
#define FLUSH_ARRAY_SIZE (512*4)
57
 
#define DELAY_DELETE_SIZE (1024)        /* vl: original was 16 */
58
57
 
59
58
#define LOG_OBJECT_ARRAY_DELTA 8
60
59
 
68
67
 
69
68
class LogBufferManager
70
69
{
71
 
private:
72
 
  ink_mutex _flush_array_mutex; // synchronize access to flush_array
73
 
  LogBuffer *_flush_list;
74
 
  LogBuffer **_flush_list_last;
75
 
  LogBuffer *_delay_delete_array[DELAY_DELETE_SIZE];
76
 
  int _head;                    // index of next buffer in deleted list
77
 
 
78
 
public:
79
 
 LogBufferManager()
80
 
   : _flush_list(0), _head(0)
81
 
  {
82
 
    _flush_list_last = &_flush_list;
83
 
    for (int i = 0; i < DELAY_DELETE_SIZE; i++)
84
 
      _delay_delete_array[i] = 0;
85
 
    ink_mutex_init(&_flush_array_mutex, "_flush_array_mutex");
86
 
  }
87
 
 
88
 
  ~LogBufferManager();
89
 
 
90
 
  void add_to_flush_queue(LogBuffer * buffer)
91
 
  {
92
 
    if (buffer && buffer->sign == CLASS_SIGN_LOGBUFFER) {
93
 
      ink_mutex_acquire(&_flush_array_mutex);
94
 
      (*_flush_list_last = buffer)->next_flush = 0;
95
 
      _flush_list_last = &buffer->next_flush;
96
 
      ink_mutex_release(&_flush_array_mutex);
 
70
  private:
 
71
    ASLL(LogBuffer, write_link) write_list;
 
72
    int _num_flush_buffers;
 
73
 
 
74
  public:
 
75
    LogBufferManager() : _num_flush_buffers(0) { }
 
76
 
 
77
    void add_to_flush_queue(LogBuffer *buffer) {
 
78
    write_list.push(buffer);
 
79
    ink_atomic_increment(&_num_flush_buffers, 1);
97
80
    }
98
 
  }
99
 
 
100
 
  LogBuffer *get_flush_queue(void)
101
 
  {
102
 
    LogBuffer *list;
103
 
    ink_mutex_acquire(&_flush_array_mutex);
104
 
    list = _flush_list;
105
 
    _flush_list = 0;
106
 
    _flush_list_last = &_flush_list;
107
 
    ink_mutex_release(&_flush_array_mutex);
108
 
    return list;
109
 
  }
110
 
 
111
 
  size_t flush_buffers(LogBufferSink * sink, size_t * to_disk, size_t * to_net, size_t * to_pipe);
 
81
 
 
82
    size_t flush_buffers(LogBufferSink *sink);
112
83
};
113
84
 
114
 
 
115
85
class LogObject
116
86
{
117
87
public:
128
98
  // WRITES_TO_PIPE: object writes to a named pipe rather than to a file
129
99
 
130
100
  LogObject(LogFormat *format, const char *log_dir, const char *basename,
131
 
            LogFileFormat file_format, const char *header,
132
 
            int rolling_enabled, int rolling_interval_sec = 0, int rolling_offset_hr = 0, int rolling_size_mb = 0);
133
 
  LogObject(LogFormat format, const char *log_dir, const char *basename,
134
 
            LogFileFormat file_format, const char *header,
135
 
            int rolling_enabled, int rolling_interval_sec = 0, int rolling_offset_hr = 0, int rolling_size_mb = 0);
136
 
private:
137
 
  void init(LogFormat * format, const char *log_dir, const char *basename,
138
 
            LogFileFormat file_format, const char *header,
139
 
            int rolling_enabled, int rolling_interval_sec = 0, int rolling_offset_hr = 0, int rolling_size_mb = 0);
 
101
                 LogFileFormat file_format, const char *header,
 
102
                 int rolling_enabled, int rolling_interval_sec = 0,
 
103
                 int rolling_offset_hr = 0, int rolling_size_mb = 0);
140
104
  LogObject(LogObject &);
141
 
 
142
 
public:
143
105
  virtual ~LogObject();
144
106
 
145
107
  void add_filter(LogFilter * filter, bool copy = true);
146
108
  void set_filter_list(const LogFilterList & list, bool copy = true);
147
109
  void add_loghost(LogHost * host, bool copy = true);
148
110
 
149
 
  void set_remote_flag()
150
 
  {
151
 
    m_flags |= REMOTE_DATA;
152
 
  };
 
111
  void set_remote_flag() { m_flags |= REMOTE_DATA; };
153
112
 
154
113
  int log(LogAccess * lad, char *text_entry = NULL);
155
 
  int roll_files_if_needed(long time_now = 0);
156
 
 
157
 
  int roll_files(long time_now = 0) {
158
 
    return _roll_files(m_last_roll_time, time_now ? time_now : LogUtils::timestamp());
159
 
  }
160
 
 
161
 
  void add_to_flush_queue(LogBuffer * buffer)
162
 
  {
163
 
    m_buffer_manager.add_to_flush_queue(buffer);
164
 
  }
165
 
 
166
 
  size_t flush_buffers(size_t * to_disk, size_t * to_net, size_t * to_pipe)
167
 
  {
168
 
    return (m_logFile) ? m_buffer_manager.flush_buffers(m_logFile, to_disk, to_net, to_pipe) :
169
 
      m_buffer_manager.flush_buffers(&m_host_list, to_disk, to_net, to_pipe);
 
114
 
 
115
  int roll_files(long time_now = 0);
 
116
 
 
117
  void add_to_flush_queue(LogBuffer * buffer) { m_buffer_manager.add_to_flush_queue(buffer); }
 
118
 
 
119
  size_t flush_buffers()
 
120
  {
 
121
    size_t nfb;
 
122
 
 
123
    if (m_logFile) {
 
124
      nfb = m_buffer_manager.flush_buffers(m_logFile);
 
125
    } else {
 
126
      nfb = m_buffer_manager.flush_buffers(&m_host_list);
 
127
    }
 
128
    return nfb;
170
129
  }
171
130
 
172
131
  void check_buffer_expiration(long time_now);
175
134
  void displayAsXML(FILE * fd = stdout, bool extended = false);
176
135
  static uint64_t compute_signature(LogFormat * format, char *filename, unsigned int flags);
177
136
 
178
 
  char *get_original_filename() const
179
 
  {
180
 
    return m_filename;
181
 
  }
182
 
 
183
 
  char *get_full_filename() const
184
 
  {
185
 
    return (m_alt_filename ? m_alt_filename : m_filename);
186
 
  }
187
 
 
188
 
  char *get_base_filename() const
189
 
  {
190
 
    return m_basename;
191
 
  }
 
137
  char *get_original_filename() const { return m_filename; }
 
138
  char *get_full_filename() const { return (m_alt_filename ? m_alt_filename : m_filename); }
 
139
  char *get_base_filename() const { return m_basename; }
192
140
 
193
141
  off_t get_file_size_bytes();
194
142
 
195
 
  uint64_t get_signature() const
196
 
  {
197
 
    return m_signature;
198
 
  }
199
 
 
200
 
  int get_rolling_interval() const
201
 
  {
202
 
    return m_rolling_interval_sec;
203
 
  }
204
 
 
205
 
  void set_log_file_header(const char *header)
206
 
  {
207
 
    m_logFile->change_header(header);
208
 
  }
 
143
  uint64_t get_signature() const { return m_signature; }
 
144
 
 
145
  int get_rolling_interval() const { return m_rolling_interval_sec; }
 
146
 
 
147
  void set_log_file_header(const char *header) { m_logFile->change_header(header); }
209
148
 
210
149
  void set_rolling_enabled(int rolling_enabled)
211
150
  {
217
156
    _setup_rolling(m_rolling_enabled, rolling_interval_sec, m_rolling_offset_hr, m_rolling_size_mb);
218
157
  }
219
158
 
220
 
  void set_rolling_offset_hr(int rolling_offset_hr)
 
159
 void set_rolling_offset_hr(int rolling_offset_hr)
221
160
  {
222
161
    _setup_rolling(m_rolling_enabled, m_rolling_interval_sec, rolling_offset_hr, m_rolling_size_mb);
223
162
  }
227
166
    m_rolling_size_mb = rolling_size_mb;
228
167
  }
229
168
 
230
 
  bool is_collation_client()
231
 
  {
232
 
    return (m_logFile ? false : true);
233
 
  }
234
 
 
235
 
  bool receives_remote_data()
236
 
  {
237
 
    return m_flags & REMOTE_DATA ? true : false;
238
 
  }
239
 
 
240
 
  bool writes_to_pipe()
241
 
  {
242
 
    return m_flags & WRITES_TO_PIPE ? true : false;
243
 
  }
244
 
 
245
 
  bool writes_to_disk()
246
 
  {
247
 
    return (m_logFile && !(m_flags & WRITES_TO_PIPE) ? true : false);
248
 
  }
249
 
 
250
 
  unsigned int get_flags() const
251
 
  {
252
 
    return m_flags;
253
 
  }
 
169
  bool is_collation_client() const { return (m_logFile ? false : true); }
 
170
  bool receives_remote_data() const { return m_flags & REMOTE_DATA ? true : false; }
 
171
  bool writes_to_pipe() const { return m_flags & WRITES_TO_PIPE ? true : false; }
 
172
  bool writes_to_disk() { return (m_logFile && !(m_flags & WRITES_TO_PIPE) ? true : false); }
 
173
 
 
174
  unsigned int get_flags() const { return m_flags; }
254
175
 
255
176
  void rename(char *new_name);
256
177
 
257
 
  bool has_alternate_name()
258
 
  {
259
 
    return (m_alt_filename ? true : false);
260
 
  }
261
 
 
262
 
  const char *get_format_string()
263
 
  {
264
 
    return (m_format ? m_format->format_string() : "<none>");
265
 
  }
266
 
 
267
 
  void force_new_buffer()
268
 
  {
 
178
  bool has_alternate_name() const { return (m_alt_filename ? true : false); }
 
179
 
 
180
  const char *get_format_string() { return (m_format ? m_format->format_string() : "<none>"); }
 
181
 
 
182
  void force_new_buffer() {
269
183
    _checkout_write(NULL, 0);
270
184
  }
271
185
 
302
216
 
303
217
  int m_ref_count;
304
218
 
305
 
  LogBuffer *volatile m_log_buffer;     // current work buffer
 
219
  volatile head_p m_log_buffer;     // current work buffer
306
220
  LogBufferManager m_buffer_manager;
307
221
 
308
222
  void generate_filenames(const char *log_dir, const char *basename, LogFileFormat file_format);
368
282
class LogObjectManager
369
283
{
370
284
public:
371
 
 
372
285
  // error status
373
286
  //
374
287
  enum
382
295
 
383
296
private:
384
297
 
385
 
    LogObject ** _objects;      // array of objects managed
 
298
  LogObject ** _objects;      // array of objects managed
386
299
  size_t _numObjects;           // the number of objects managed
387
300
  size_t _maxObjects;           // the maximum capacity of the array
388
301
  // of objects managed
421
334
    for (unsigned int i = 0; i < _maxObjects; i++) {
422
335
      delete _objects[i];
423
336
    }
424
 
    delete[]_objects;
 
337
    delete[] _objects;
425
338
 
426
339
    for (unsigned int i = 0; i < _maxAPIobjects; i++) {
427
340
      delete _APIobjects[i];
428
341
    }
429
 
    delete[]_APIobjects;
 
342
    delete[] _APIobjects;
430
343
 
431
344
    delete _APImutex;
432
345
  }
448
361
 
449
362
  LogObject *get_object_with_signature(uint64_t signature);
450
363
  void check_buffer_expiration(long time_now);
451
 
  size_t get_num_objects()
452
 
  {
453
 
    return _numObjects;
454
 
  }
455
 
 
456
 
  int roll_files(long time_now = 0) {
457
 
    return _roll_files(time_now, false);
458
 
  }
459
 
 
460
 
  int roll_files_if_needed(long time_now = 0) {
461
 
    return _roll_files(time_now, true);
462
 
  }
 
364
  size_t get_num_objects() const { return _numObjects; }
 
365
 
 
366
  int roll_files(long time_now);
463
367
 
464
368
  int log(LogAccess * lad);
465
369
  void display(FILE * str = stdout);
466
370
  void add_filter_to_all(LogFilter * filter);
467
371
  LogObject *find_by_format_name(const char *name);
468
 
  size_t flush_buffers(size_t * to_disk, size_t * to_net = 0, size_t * to_pipe = 0);
 
372
  size_t flush_buffers();
469
373
  void open_local_pipes();
470
374
  void transfer_objects(LogObjectManager & mgr);
471
375
 
472
 
  bool has_api_objects() const  {
473
 
    return (_numAPIobjects > 0);
474
 
  }
 
376
  bool has_api_objects() const  { return (_numAPIobjects > 0); }
475
377
 
476
378
  size_t get_num_collation_clients();
477
379
};
478
380
 
 
381
inline int LogObjectManager::roll_files(long time_now)
 
382
{
 
383
    int num_rolled = 0;
 
384
    for (size_t i=0; i < _numObjects; i++) {
 
385
      num_rolled += _objects[i]->roll_files(time_now);
 
386
    }
 
387
    return num_rolled;
 
388
};
479
389
 
480
390
inline int
481
391
LogObjectManager::log(LogAccess * lad)