class ListMetricData(command.Lister):
_description = _("list metric data")
def get_parser(self, prog_name):
parser = super(ListMetricData, self).get_parser(prog_name)
pb.MetricParser.add_namespace_arg(parser, True)
pb.MetricParser.add_metric_name_arg(parser, True)
pb.MetricParser.add_from_arg(parser)
pb.MetricParser.add_to_arg(parser)
pb.MetricParser.add_period_arg(parser)
pb.MetricParser.add_filter_arg(parser)
pb.MetricParser.add_dimension_arg(parser, True)
return parser
def take_action(self, args):
metric_mgr = self.app.client_manager.cloudeye.metric_mgr
dimensions = [
dimension.replace('=', ',') for dimension in args.dimensions
]
data = metric_mgr.list_metric_data(namespace=args.namespace,
metric_name=args.metric_name,
from_=args.from_,
to=args.to,
period=args.period,
filter_=args.filter,
dimensions=dimensions)
columns = ["timestamp", args.filter, "unit"]
formatter = resource.MetricData.formatter
return columns, (r.get_display_data(columns, formatter) for r in data)
def add_filter_arg(parser, required=True):
parser.add_argument(
"--filter",
required=required,
choices=["average", "variance", "min", "max"],
help=_("filter by data aggregation method"),
)
class AddMetricData(command.Command):
_description = _("add metric data")
def get_parser(self, prog_name):
parser = super(AddMetricData, self).get_parser(prog_name)
pb.MetricParser.add_custom_namespace_arg(parser, True)
pb.MetricParser.add_metric_name_arg(parser, True)
pb.MetricParser.add_dimension_arg(parser, True)
pb.MetricParser.add_ttl_arg(parser, True)
pb.MetricParser.add_collect_time_arg(parser, True)
pb.MetricParser.add_value_arg(parser, True)
pb.MetricParser.add_unit_arg(parser, False)
pb.MetricParser.add_type_arg(parser, False)
return parser
def take_action(self, args):
metric_mgr = self.app.client_manager.cloudeye.metric_mgr
dimensions = []
for dimension in args.dimensions:
split = dimension.split("=")
dimensions.append({"name": split[0], "value": split[1]})
metric_mgr.add_metric_data(namespace=args.namespace,
metric_name=args.metric_name,
dimensions=dimensions,
ttl=args.ttl,
collect_time=args.collect_time,
value=args.value,
unit=args.unit,
type_=args.type_)
return 'Metric data has been added'
def add_unit_arg(parser, required=False):
parser.add_argument(
"--unit",
required=required,
metavar="<unit>",
help=_("metric data unit, example: %%, Mb"),
)
def add_start_arg(parser, required=False):
parser.add_argument(
"--start",
required=required,
metavar="<alarm-id>",
help=_("list alarms after the alarm-id"),
)
def add_metric_name_arg(parser, required=False):
parser.add_argument(
"--metric-name",
required=required,
metavar="<metric-name>",
help=_("list metric with name(example: cpu_utils)")
)
class ListMetric(command.Lister):
_description = _("list metrics")
def get_parser(self, prog_name):
parser = super(ListMetric, self).get_parser(prog_name)
pb.MetricParser.add_namespace_arg(parser)
pb.MetricParser.add_metric_name_arg(parser)
pb.MetricParser.add_dimension_arg(parser)
pb.MetricParser.add_start_arg(parser)
bpb.BaseParser.add_limit_option(parser, 1000)
bpb.BaseParser.add_order_option(parser)
return parser
def take_action(self, args):
metric_mgr = self.app.client_manager.cloudeye.metric_mgr
dimensions = [
dimension.replace('=', ',') for dimension in args.dimensions
]
start = args.start.replace('=', ':') if args.start else None
metrics = metric_mgr.list(namespace=args.namespace,
metric_name=args.metric_name,
dimensions=dimensions,
start=start,
limit=args.limit,
order=args.order)
columns = resource.Metric.list_column_names
return columns, (m.get_display_data(columns) for m in metrics)
def add_ttl_arg(parser, required=True):
parser.add_argument(
"--ttl",
required=required,
metavar="<second>",
type=int,
help=_("metric data keeps time(second), max is 604800"),
)
def add_period_arg(parser, required=True):
parser.add_argument(
"--period",
required=required,
choices=["1", "300", "1200", "3600", "14400", "86400"],
help=_("Monitor granularity (second), "
"1 stands for real-time"),
)
def add_start_arg(parser, required=False):
parser.add_argument(
"--start",
required=required,
metavar="<key=value>",
help=_("return result list start from ("
"namespace.metric-name.key:value)"),
)
def add_type_arg(parser, required=False):
parser.add_argument(
"--type",
required=required,
dest="type_",
choices=["int", "float"],
help=_("metric data type"),
)
def add_value_arg(parser, required=True):
parser.add_argument(
"--value",
required=required,
metavar="<value>",
type=float,
help=_("metric data value"),
)
def add_namespace_arg(parser, required=False):
parser.add_argument(
"--namespace",
required=required,
# choices=MetricParser.namespaces,
help=_("list metric with namespace "
"(examples: SYS.ECS, SYS.EVS, SYS.AS)")
)
def add_custom_namespace_arg(parser, required=True):
parser.add_argument(
"--namespace",
metavar="<namespace>",
required=required,
help=_("metric namespace (service.item), should not "
"starts with SYS, length should be 3-32")
)
def add_to_arg(parser, required=True):
parser.add_argument(
"--to",
required=required,
metavar="<yyyy-MM-ddTHH:mm:ss>",
type=parsetypes.date_type('%Y-%m-%dT%H:%M:%S'),
help=_("metric data before this time "
"(UTC timestamp with format yyyy-MM-ddTHH:mm:ss)"),
)
def add_from_arg(parser, required=True):
parser.add_argument(
"--from",
required=required,
dest="from_",
metavar="<yyyy-MM-ddTHH:mm:ss>",
type=parsetypes.date_type('%Y-%m-%dT%H:%M:%S'),
help=_("metric data after this time "
"(UTC timestamp with format yyyy-MM-ddTHH:mm:ss)"),
)
def add_dimension_arg(parser, required=False):
parser.add_argument(
"--dimension",
required=required,
metavar="<key=value>",
default=[],
dest="dimensions",
action='append',
help=_("Metric dimension (repeat to set multiple "
"dimension, max repeat time is 3)"),
)
class ListQuota(command.Lister):
_description = _("list quota")
def get_parser(self, prog_name):
parser = super(ListQuota, self).get_parser(prog_name)
return parser
def take_action(self, args):
quota_mgr = self.app.client_manager.cloudeye.quota_mgr
quotas = quota_mgr.list()
columns = resource.Quota.list_column_names
return columns, (q.get_display_data(columns) for q in quotas)
class ListFavoriteMetric(command.Lister):
_description = _("list favorite metrics")
def get_parser(self, prog_name):
parser = super(ListFavoriteMetric, self).get_parser(prog_name)
return parser
def take_action(self, args):
metric_mgr = self.app.client_manager.cloudeye.metric_mgr
metrics = metric_mgr.list_favorite()
columns = resource.Metric.list_favorite_column_names
return columns, (m.get_display_data(columns) for m in metrics)
class DeleteAlarm(command.Command):
_description = _("delete alarm")
def get_parser(self, prog_name):
parser = super(DeleteAlarm, self).get_parser(prog_name)
pb.AlarmParser.add_alarm_id_arg(parser, 'delete')
return parser
def take_action(self, args):
alarm_mgr = self.app.client_manager.cloudeye.alarm_mgr
alarm_mgr.delete(args.alarm_id)
return "Alarm %s has been deleted" % args.alarm_id
def register_service_option(parser, service_type):
service_env = service_type.upper().replace('-', '_')
parser.add_argument('--os-{service_type}-api-version'.format(
service_type=service_type),
metavar='<%s-api-version>' % service_type,
default=os.environ.get(
'OS_{service_type}_API_VERSION'.format(
service_type=service_env), None),
help=(_(
'Which version of the service API to use for'
' the {service_type} service').format(
service_type=service_type)))
parser.add_argument(
'--os-{service_type}-endpoint-override'.format(
service_type=service_type),
metavar='<%s-endpoint-override>' % service_type,
default=os.environ.get(
'OS_{service_type}_ENDPOINT_OVERRIDE'.format(
service_type=service_env), None),
help=(_('Endpoint to use for the {service_type} service'
' instead of the endpoint in the catalog').format(
service_type=service_type)))
class ShowAlarm(command.ShowOne):
_description = _("show alarm")
def get_parser(self, prog_name):
parser = super(ShowAlarm, self).get_parser(prog_name)
pb.AlarmParser.add_alarm_id_arg(parser, 'shown')
return parser
def take_action(self, args):
alarm_mgr = self.app.client_manager.cloudeye.alarm_mgr
alarm = alarm_mgr.get(args.alarm_id)
columns = resource.Alarm.show_column_names
formatter = resource.Alarm.formatter
return columns, alarm.get_display_data(columns, formatter)
class ListAlarm(command.Lister):
_description = _("list alarm")
def get_parser(self, prog_name):
parser = super(ListAlarm, self).get_parser(prog_name)
pb.AlarmParser.add_start_arg(parser)
bpb.BaseParser.add_limit_option(parser, 100)
bpb.BaseParser.add_order_option(parser)
return parser
def take_action(self, args):
alarm_mgr = self.app.client_manager.cloudeye.alarm_mgr
alarms = alarm_mgr.list(start=args.start,
limit=args.limit,
order=args.order)
columns = resource.Alarm.list_column_names
return columns, (a.get_display_data(columns) for a in alarms)
def add_sortdir_option(parser):
parser.add_argument("--sort-dir",
choices=['desc', 'asc'],
help=_("Sort by, default is desc"))
def add_offset_option(parser):
parser.add_argument("--offset",
type=int,
metavar="<offset>",
help=_("return result offset"))
def add_limit_option(parser, max_number):
parser.add_argument("--limit",
metavar="<limit>",
type=parsetypes.int_range_type(1, max_number),
help=_("return result limit, max size is %d" %
max_number))
def add_order_option(parser):
parser.add_argument("--order",
choices=['desc', 'asc'],
help=_("Sort by, default is desc"))
def add_alarm_id_arg(parser, op):
parser.add_argument(
"alarm_id",
metavar="<alarm-id>",
help=_("Alarm to be %s (alarm-id)" % op),
)
