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 30 31 32 33 34 35 36 37 38 39 40 41 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 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 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 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160
|
package meters
import (
"reflect"
"time"
"github.com/mitchellh/mapstructure"
"github.com/rackspace/gophercloud"
)
type Meter struct {
MeterId string `mapstructure:"meter_id"`
Name string `json:"name"`
ProjectId string `mapstructure:"project_id"`
ResourceId string `mapstructure:"resource_id"`
Source string `json:"source"`
Type string `json:"type"`
Unit string `json:"user"`
UserId string `mapstructure:"user_id"`
}
type OldSample struct {
Name string `mapstructure:"counter_name"`
Type string `mapstructure:"counter_type"`
Unit string `mapstructure:"counter_unit"`
Volume float32 `mapstructure:"counter_volume"`
MessageId string `mapstructure:"message_id"`
ProjectId string `mapstructure:"project_id"`
RecordedAt time.Time `mapstructure:"recorded_at"`
ResourceId string `mapstructure:"resource_id"`
ResourceMetadata map[string]string `mapstructure:"resource_metadata"`
Source string `mapstructure:"source"`
Timestamp time.Time `mapstructure:"timestamp"`
UserId string `mapstructure:"user_id"`
}
type ListResult struct {
gophercloud.Result
}
// Extract interprets any ListResult as an array of Meter
func (r ListResult) Extract() ([]Meter, error) {
if r.Err != nil {
return nil, r.Err
}
var response []Meter
config := &mapstructure.DecoderConfig{
DecodeHook: toMapFromString,
Result: &response,
}
decoder, err := mapstructure.NewDecoder(config)
if err != nil {
return nil, err
}
err = decoder.Decode(r.Body)
if err != nil {
return nil, err
}
return response, nil
}
type ShowResult struct {
gophercloud.Result
}
func (r ShowResult) Extract() ([]OldSample, error) {
if r.Err != nil {
return nil, r.Err
}
var response []OldSample
config := &mapstructure.DecoderConfig{
DecodeHook: decoderHooks,
Result: &response,
}
decoder, err := mapstructure.NewDecoder(config)
if err != nil {
return nil, err
}
err = decoder.Decode(r.Body)
if err != nil {
return nil, err
}
return response, nil
}
type Statistics struct {
Avg float32 `json:"avg"`
Count int `json:"count"`
Duration float32 `json:"duration"`
DurationEnd string `mapstructure:"duration_end"`
DurationStart string `mapstructure:"duration_start"`
Max float32 `json:"max"`
Min float32 `json:"min"`
Period int `json:"user_id"`
PeriodEnd string `mapstructure:"period_end"`
PeriodStart string `mapstructure:"period_start"`
Sum float32 `json:"sum"`
Unit string `json:"unit"`
}
type StatisticsResult struct {
gophercloud.Result
}
// Extract interprets any serverResult as a Server, if possible.
func (r StatisticsResult) Extract() ([]Statistics, error) {
if r.Err != nil {
return nil, r.Err
}
var response []Statistics
config := &mapstructure.DecoderConfig{
DecodeHook: toMapFromString,
Result: &response,
}
decoder, err := mapstructure.NewDecoder(config)
if err != nil {
return nil, err
}
err = decoder.Decode(r.Body)
if err != nil {
return nil, err
}
return response, nil
}
func decoderHooks(from reflect.Type, to reflect.Type, data interface{}) (interface{}, error) {
if (from.Kind() == reflect.String) && (to.Kind() == reflect.Map) {
return toMapFromString(from.Kind(), to.Kind(), data)
} else if to == reflect.TypeOf(time.Time{}) && from == reflect.TypeOf("") {
return toDateFromString(from, to, data)
}
return data, nil
}
func toMapFromString(from reflect.Kind, to reflect.Kind, data interface{}) (interface{}, error) {
if (from == reflect.String) && (to == reflect.Map) {
return map[string]interface{}{}, nil
}
return data, nil
}
// From https://github.com/mitchellh/mapstructure/issues/41
func toDateFromString(from reflect.Type, to reflect.Type, data interface{}) (interface{}, error) {
if to == reflect.TypeOf(time.Time{}) && from == reflect.TypeOf("") {
return time.Parse("2006-01-02T15:04:05.999999999", data.(string))
}
return data, nil
}
|