← Back to branch summary

~ubuntu-branches/ubuntu/trusty/ceilometer/trusty-proposed

« back to all changes in this revision

Viewing changes to ceilometer/storage/__init__.py

  • Committer: Package Import Robot
  • Author(s): Chuck Short, James Page, Chuck Short
  • Date: 2014-01-23 15:08:11 UTC
  • mfrom: (1.1.11)
  • Revision ID: package-import@ubuntu.com-20140123150811-1zaismsuyh1hcl8y
Tags: 2014.1~b2-0ubuntu1
https://launchpad.net/bugs/1261101
https://launchpad.net/bugs/1250002
https://launchpad.net/bugs/1224223
[ James Page ]
* d/control: Add python-jsonpath-rw to BD's.
* d/p/fix-setup-requirements.patch: Bump WebOb to support < 1.4.
 (LP: #1261101)

[ Chuck Short ]
* New upstream version.
* debian/control, debian/ceilometer-common.install: Split out
  ceilometer-alarm-evaluator and ceilometer-alarm-notifier into their
  own packages. (LP: #1250002)
* debian/ceilometer-agent-central.logrotate,
  debian/ceilometer-agent-compute.logrotate,
  debian/ceilometer-api.logrotate,
  debian/ceilometer-collector.logrotate: Add logrotate files, 
  thanks to Ahmed Rahal. (LP: #1224223)
* Fix typos in upstart files.

Show diffs side-by-side

added added

removed removed

Lines of Context:
ceilometer/storage/__init__.py
21
21
import urlparse
22
22
 
23
23
from oslo.config import cfg
 
24
import six
24
25
from stevedore import driver
25
26
 
26
27
from ceilometer.openstack.common.gettextutils import _  # noqa
94
95
    :param resource: Optional filter for resource id.
95
96
    :param meter: Optional filter for meter type using the meter name.
96
97
    :param source: Optional source filter.
 
98
    :param message_id: Optional sample_id filter.
97
99
    :param metaquery: Optional filter on the metadata
98
100
    """
99
101
    def __init__(self, user=None, project=None,
100
102
                 start=None, start_timestamp_op=None,
101
103
                 end=None, end_timestamp_op=None,
102
104
                 resource=None, meter=None,
103
 
                 source=None, metaquery={}):
 
105
                 source=None, message_id=None,
 
106
                 metaquery={}):
104
107
        self.user = user
105
108
        self.project = project
106
109
        self.start = utils.sanitize_timestamp(start)
111
114
        self.meter = meter
112
115
        self.source = source
113
116
        self.metaquery = metaquery
 
117
        self.message_id = message_id
114
118
 
115
119
 
116
120
class EventFilter(object):
117
121
    """Properties for building an Event query.
118
122
 
119
 
    :param start: UTC start datetime (mandatory)
120
 
    :param end: UTC end datetime (mandatory)
 
123
    :param start_time: UTC start datetime (mandatory)
 
124
    :param end_time: UTC end datetime (mandatory)
121
125
    :param event_type: the name of the event. None for all.
122
 
    :param traits: the trait filter dict, all of which are optional
 
126
    :param message_id: the message_id of the event. None for all.
 
127
    :param traits_filter: the trait filter dicts, all of which are optional.
 
128
                   This parameter is a list of dictionaries that specify
 
129
                   trait values:
123
130
                    {'key': <key>,
124
 
                    't_string': <value>,
125
 
                    't_int': <value>,
126
 
                    't_datetime': <value>
127
 
                    't_float': <value>}
128
 
                   currently, only one trait dict is supported.
 
131
                    'string': <value>,
 
132
                    'integer': <value>,
 
133
                    'datetime': <value>,
 
134
                    'float': <value>,
 
135
                    'op': <eq, lt, le, ne, gt or ge> }
129
136
    """
130
137
 
131
 
    def __init__(self, start, end, event_type=None, traits={}):
132
 
        self.start = utils.sanitize_timestamp(start)
133
 
        self.end = utils.sanitize_timestamp(end)
 
138
    def __init__(self, start_time=None, end_time=None, event_type=None,
 
139
                 message_id=None, traits_filter=[]):
 
140
        self.start_time = utils.sanitize_timestamp(start_time)
 
141
        self.end_time = utils.sanitize_timestamp(end_time)
 
142
        self.message_id = message_id
134
143
        self.event_type = event_type
135
 
        self.traits = traits
 
144
        self.traits_filter = traits_filter
 
145
 
 
146
    def __repr__(self):
 
147
        return ("<EventFilter(start_time: %s,"
 
148
                " end_time: %s,"
 
149
                " event_type: %s,"
 
150
                " traits: %s)>" %
 
151
                (self.start_time,
 
152
                 self.end_time,
 
153
                 self.event_type,
 
154
                 six.text_type(self.traits_filter)))
136
155
 
137
156
 
138
157
def dbsync():