← Back to branch summary

~ps10gel/ubuntu/xenial/trafficserver/6.2.0

« back to all changes in this revision

Viewing changes to lib/records/RecUtils.cc

  • Committer: Bazaar Package Importer
  • Author(s): Arno Toell
  • Date: 2011-01-13 11:49:18 UTC
  • Revision ID: james.westby@ubuntu.com-20110113114918-vu422h8dknrgkj15
Tags: upstream-2.1.5-unstable
Import upstream version 2.1.5-unstable

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/records/RecUtils.cc
 
1
/** @file
 
2
 
 
3
  Record utils definitions
 
4
 
 
5
  @section license License
 
6
 
 
7
  Licensed to the Apache Software Foundation (ASF) under one
 
8
  or more contributor license agreements.  See the NOTICE file
 
9
  distributed with this work for additional information
 
10
  regarding copyright ownership.  The ASF licenses this file
 
11
  to you under the Apache License, Version 2.0 (the
 
12
  "License"); you may not use this file except in compliance
 
13
  with the License.  You may obtain a copy of the License at
 
14
 
 
15
      http://www.apache.org/licenses/LICENSE-2.0
 
16
 
 
17
  Unless required by applicable law or agreed to in writing, software
 
18
  distributed under the License is distributed on an "AS IS" BASIS,
 
19
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 
20
  See the License for the specific language governing permissions and
 
21
  limitations under the License.
 
22
 */
 
23
 
 
24
#include "libts.h"
 
25
#include "P_RecUtils.h"
 
26
#include "P_RecCore.h"
 
27
#include "P_RecTree.h"
 
28
 
 
29
// diags defined in RecCore.cc
 
30
extern Diags *g_diags;
 
31
 
 
32
//-------------------------------------------------------------------------
 
33
// RecAlloc
 
34
//-------------------------------------------------------------------------
 
35
RecRecord*
 
36
RecAlloc(RecT rec_type, const char *name, RecDataT data_type)
 
37
{
 
38
  if (g_num_records >= REC_MAX_RECORDS) {
 
39
    Warning("too many stats/configs, please increase REC_MAX_RECORDS or rebuild with --with_max_api_stats=<n>");
 
40
    return NULL;
 
41
  }
 
42
 
 
43
  int i = ink_atomic_increment(&g_num_records, 1);
 
44
  RecRecord *r = &(g_records[i]);
 
45
  // Note: record should already be memset to 0 from RecCoreInit()
 
46
  r->rec_type = rec_type;
 
47
  r->name = xstrdup(name);
 
48
  r->order = i;
 
49
  r->data_type = data_type;
 
50
  rec_mutex_init(&(r->lock), NULL);
 
51
 
 
52
  g_records_tree->rec_tree_insert(r->name);
 
53
 
 
54
  return r;
 
55
}
 
56
 
 
57
 
 
58
//-------------------------------------------------------------------------
 
59
// RecDataClear
 
60
//-------------------------------------------------------------------------
 
61
void
 
62
RecDataClear(RecDataT data_type, RecData * data)
 
63
{
 
64
  if ((data_type == RECD_STRING) && (data->rec_string)) {
 
65
    xfree(data->rec_string);
 
66
  }
 
67
  memset(data, 0, sizeof(RecData));
 
68
}
 
69
 
 
70
 
 
71
//-------------------------------------------------------------------------
 
72
// RecDataSet
 
73
//-------------------------------------------------------------------------
 
74
bool
 
75
RecDataSet(RecDataT data_type, RecData * data_dst, RecData * data_src)
 
76
{
 
77
  bool rec_set = false;
 
78
 
 
79
  switch (data_type) {
 
80
  case RECD_STRING:
 
81
    if (data_src->rec_string == NULL) {
 
82
      if (data_dst->rec_string != NULL) {
 
83
        xfree(data_dst->rec_string);
 
84
        data_dst->rec_string = NULL;
 
85
        rec_set = true;
 
86
      }
 
87
    } else if (((data_dst->rec_string) && (strcmp(data_dst->rec_string, data_src->rec_string) != 0)) ||
 
88
               ((data_dst->rec_string == NULL) && (data_src->rec_string != NULL))) {
 
89
      if (data_dst->rec_string) {
 
90
        xfree(data_dst->rec_string);
 
91
      }
 
92
      data_dst->rec_string = xstrdup(data_src->rec_string);
 
93
      rec_set = true;
 
94
    }
 
95
    break;
 
96
  case RECD_INT:
 
97
    if (data_dst->rec_int != data_src->rec_int) {
 
98
      data_dst->rec_int = data_src->rec_int;
 
99
      rec_set = true;
 
100
    }
 
101
    break;
 
102
  case RECD_FLOAT:
 
103
    if (data_dst->rec_float != data_src->rec_float) {
 
104
      data_dst->rec_float = data_src->rec_float;
 
105
      rec_set = true;
 
106
    }
 
107
    break;
 
108
  case RECD_COUNTER:
 
109
    if (data_dst->rec_counter != data_src->rec_counter) {
 
110
      data_dst->rec_counter = data_src->rec_counter;
 
111
      rec_set = true;
 
112
    }
 
113
    break;
 
114
  default:
 
115
    ink_assert(!"Wrong RECD type!");
 
116
  }
 
117
  return rec_set;
 
118
 
 
119
}
 
120
 
 
121
 
 
122
//-------------------------------------------------------------------------
 
123
// RecDataSetFromInk64
 
124
//-------------------------------------------------------------------------
 
125
bool
 
126
RecDataSetFromInk64(RecDataT data_type, RecData * data_dst, int64_t data_int64)
 
127
{
 
128
  switch (data_type) {
 
129
  case RECD_INT:
 
130
    data_dst->rec_int = data_int64;
 
131
    break;
 
132
  case RECD_FLOAT:
 
133
    data_dst->rec_float = (float) (data_int64);
 
134
    break;
 
135
  case RECD_STRING:
 
136
    {
 
137
      char buf[32 + 1];
 
138
      if (data_dst->rec_string) {
 
139
        xfree(data_dst->rec_string);
 
140
      }
 
141
      snprintf(buf, 32, "%" PRId64 "", data_int64);
 
142
      data_dst->rec_string = xstrdup(buf);
 
143
      break;
 
144
    }
 
145
  case RECD_COUNTER:
 
146
    data_dst->rec_counter = data_int64;
 
147
    break;
 
148
  default:
 
149
    ink_debug_assert(!"Unexpected RecD type");
 
150
    return false;
 
151
  }
 
152
 
 
153
  return true;
 
154
}
 
155
 
 
156
 
 
157
//-------------------------------------------------------------------------
 
158
// RecDataSetFromFloat
 
159
//-------------------------------------------------------------------------
 
160
bool
 
161
RecDataSetFromFloat(RecDataT data_type, RecData * data_dst, float data_float)
 
162
{
 
163
  switch (data_type) {
 
164
  case RECD_INT:
 
165
    data_dst->rec_int = (RecInt) data_float;
 
166
    break;
 
167
  case RECD_FLOAT:
 
168
    data_dst->rec_float = (float) (data_float);
 
169
    break;
 
170
  case RECD_STRING:
 
171
    {
 
172
      char buf[32 + 1];
 
173
      if (data_dst->rec_string) {
 
174
        xfree(data_dst->rec_string);
 
175
      }
 
176
      snprintf(buf, 32, "%f", data_float);
 
177
      data_dst->rec_string = xstrdup(buf);
 
178
      break;
 
179
    }
 
180
  case RECD_COUNTER:
 
181
    data_dst->rec_counter = (RecCounter) data_float;
 
182
    break;
 
183
  default:
 
184
    ink_debug_assert(!"Unexpected RecD type");
 
185
    return false;
 
186
  }
 
187
 
 
188
  return true;
 
189
}
 
190
 
 
191
 
 
192
//-------------------------------------------------------------------------
 
193
// RecDataSetFromString
 
194
//-------------------------------------------------------------------------
 
195
bool
 
196
RecDataSetFromString(RecDataT data_type, RecData * data_dst, char *data_string)
 
197
{
 
198
  bool rec_set;
 
199
  RecData data_src;
 
200
 
 
201
  switch (data_type) {
 
202
  case RECD_INT:
 
203
    data_src.rec_int = ink_atoi64(data_string);
 
204
    break;
 
205
  case RECD_FLOAT:
 
206
    data_src.rec_float = atof(data_string);
 
207
    break;
 
208
  case RECD_STRING:
 
209
    if (strcmp((data_string), "NULL") == 0)
 
210
      data_src.rec_string = NULL;
 
211
    else
 
212
      data_src.rec_string = data_string;
 
213
    break;
 
214
  case RECD_COUNTER:
 
215
    data_src.rec_counter = ink_atoi64(data_string);
 
216
    break;
 
217
  default:
 
218
    ink_debug_assert(!"Unexpected RecD type");
 
219
    return false;
 
220
  }
 
221
  rec_set = RecDataSet(data_type, data_dst, &data_src);
 
222
 
 
223
  return rec_set;
 
224
}
 
225
 
 
226
 
 
227
//-------------------------------------------------------------------------
 
228
// RecLog
 
229
//-------------------------------------------------------------------------
 
230
void
 
231
RecLog(DiagsLevel dl, const char *format_string, ...)
 
232
{
 
233
  va_list ap;
 
234
 
 
235
  va_start(ap, format_string);
 
236
  if (g_diags) {
 
237
    g_diags->log_va(NULL, dl, NULL, NULL, format_string, ap);
 
238
  }
 
239
  va_end(ap);
 
240
}
 
241
 
 
242
 
 
243
//-------------------------------------------------------------------------
 
244
// RecDebug
 
245
//-------------------------------------------------------------------------
 
246
void
 
247
RecDebug(DiagsLevel dl, const char *format_string, ...)
 
248
{
 
249
  va_list ap;
 
250
 
 
251
  va_start(ap, format_string);
 
252
  if (g_diags) {
 
253
    g_diags->log_va("rec", dl, NULL, NULL, format_string, ap);
 
254
  }
 
255
  va_end(ap);
 
256
}
 
257
 
 
258
 
 
259
//-------------------------------------------------------------------------
 
260
// RecDebugOff
 
261
//-------------------------------------------------------------------------
 
262
void
 
263
RecDebugOff()
 
264
{
 
265
  g_diags = NULL;
 
266
}