func (intermediate *intermediateAwsPolicyDocument) document() (*awsPolicyDocument, error) {
	var statements []*awsPolicyStatement

	switch s := intermediate.Statements.(type) {
	case []interface{}:
		if err := mapstructure.Decode(s, &statements); err != nil {
			return nil, errwrap.Wrapf("Error parsing statement: {{err}}", err)
		}
	case map[string]interface{}:
		var singleStatement *awsPolicyStatement
		if err := mapstructure.Decode(s, &singleStatement); err != nil {
			return nil, errwrap.Wrapf("Error parsing statement: {{err}}", err)
		}
		statements = append(statements, singleStatement)
	default:
		return nil, errors.New("Unknown error parsing statement")
	}

	document := &awsPolicyDocument{
		Version:    intermediate.Version,
		Id:         intermediate.Id,
		Statements: statements,
	}

	return document, nil
}
Exemple #2
0
func mapDecode(o *Order, customProvider OrderCustomProvider) (order *Order, err error) {
	/* Map OrderCustom */
	orderCustom := customProvider.NewOrderCustom()
	if orderCustom != nil && o.Custom != nil {
		err = mapstructure.Decode(o.Custom, orderCustom)
		if err != nil {
			return nil, err
		}
		o.Custom = orderCustom
	}

	/* Map PostionCustom */
	for _, position := range o.Positions {
		positionCustom := customProvider.NewPositionCustom()
		if positionCustom != nil && position.Custom != nil {

			err = mapstructure.Decode(position.Custom, positionCustom)
			if err != nil {
				return nil, err
			}
			position.Custom = positionCustom
		}
	}
	return o, nil
}
func (h *GenericHandler) Handle(event model.WatchEvent) error {

	if i, ok := event.Object.(map[string]interface{}); ok {
		var metadata *model.ObjectMeta
		var kind string
		var selector map[string]interface{}
		if h.kindHandled == RCKind {
			var rc model.ReplicationController
			mapstructure.Decode(i, &rc)
			if rc == (model.ReplicationController{}) || rc.Spec == nil {
				log.Infof("Couldn't decode %+v to rc.", i)
				return nil
			}
			kind = rc.Kind
			selector = rc.Spec.Selector
			metadata = rc.Metadata
		} else if h.kindHandled == ServiceKind {
			var svc model.Service
			mapstructure.Decode(i, &svc)
			if svc == (model.Service{}) || svc.Spec == nil {
				log.Infof("Couldn't decode %+v to service.", i)
				return nil
			}
			kind = svc.Kind
			selector = svc.Spec.Selector
			metadata = svc.Metadata
		} else {
			return fmt.Errorf("Unrecognized handled kind [%s].", h.kindHandled)
		}

		serviceEvent := &client.ExternalServiceEvent{
			ExternalId: metadata.Uid,
			EventType:  constructEventType(event),
		}

		switch event.Type {
		case "MODIFIED":
			fallthrough

		case "ADDED":
			err := h.add(selector, metadata, event, serviceEvent, constructResourceType(kind))
			if err != nil {
				return err
			}

		case "DELETED":
			service := client.Service{
				Kind: constructResourceType(kind),
			}
			serviceEvent.Service = service
		default:
			return nil
		}

		_, err := h.rancherClient.ExternalServiceEvent.Create(serviceEvent)
		return err

	}
	return fmt.Errorf("Couldn't decode event [%#v]", event)
}
Exemple #4
0
func New(credential, builder map[string]interface{}) (*DigitalOcean, error) {
	d := DigitalOcean{}

	// Credentials
	if err := mapstructure.Decode(credential, &d.Creds); err != nil {
		return nil, err
	}

	// Builder data
	if err := mapstructure.Decode(builder, &d.Builder); err != nil {
		return nil, err
	}

	if d.Creds.ClientID == "" {
		return nil, errors.New("credentials client_id is empty")
	}

	if d.Creds.APIKey == "" {
		return nil, errors.New("credentials api_key is empty")
	}

	d.Builder.ClientID = d.Creds.ClientID
	d.Builder.APIKey = d.Creds.APIKey

	d.Client = digitalocean.DigitalOceanClient{}.New(d.Creds.ClientID, d.Creds.APIKey)

	// authenticate credentials with a simple call
	_, err := d.Regions()
	if err != nil {
		return nil, errors.New("authentication with DigitalOcean failed.")
	}

	return &d, nil
}
Exemple #5
0
func handleChangeNotification(socket *websocket.Conn, userID string, err chan string) {
	res, errr := r.Table("notifications").
		Filter(r.Row.Field("UserId").
			Eq(userID)).
		Changes().
		Run(api.Sess)

	var value HandleChange
	if errr != nil {
		err <- errr.Error()
	}
	for res.Next(&value) {
		var notif api.Notification
		var simpleNotif api.WebSocketNotification

		mapstructure.Decode(value.NewVal, &notif)
		if notif.Id == "" {
			mapstructure.Decode(value.OldVal, &notif)
			simpleNotif.OldVal = true
		} else {
			simpleNotif.OldVal = false
		}
		simpleNotif.Title = "notification"
		simpleNotif.Type = notif.Type
		simpleNotif.Name = notif.Name
		simpleNotif.UserIdFrom = notif.UserIdFrom
		simpleNotif.IdLink = notif.IdLink
		simpleNotif.CreatedAt = notif.CreatedAt
		errr := socket.WriteJSON(simpleNotif)
		if errr != nil {
			err <- errr.Error()
		}
	}
}
Exemple #6
0
// mapDecode maps interfaces to specific types provided by customProvider
func mapDecode(cust *Customer, customProvider CustomerCustomProvider) (customer *Customer, err error) {
	/* Map CustomerCustom */
	customerCustom := customProvider.NewCustomerCustom()
	if customerCustom != nil && cust.Custom != nil {
		err = mapstructure.Decode(cust.Custom, customerCustom)
		if err != nil {
			return nil, err
		}
		cust.Custom = customerCustom
	}

	/* Map AddressCustom */
	for _, address := range cust.Addresses {
		addressCustom := customProvider.NewAddressCustom()
		if addressCustom != nil && address.Custom != nil {

			err = mapstructure.Decode(address.Custom, addressCustom)
			if err != nil {
				return nil, err
			}
			address.Custom = addressCustom
		}
	}
	return cust, nil
}
Exemple #7
0
// Parses YAML structure to typed list of Hops
func parseConfigMap(configMap map[string]interface{}) (hops, error) {
	if err := validateConfig(configMap); err != nil {
		return nil, err
	}

	hopsConfig := make(hops)
	rh := make(rawHops)
	err := mapstructure.Decode(configMap, &rh)
	if err != nil {
		panic(err)
	}

	for name, defs := range rh {
		for _, def := range defs {
			if dockMap, ok := def["docker"]; ok {
				docker := Docker{}
				err := mapstructure.Decode(dockMap, &docker)
				if err != nil {
					panic(err)
				}
				hopsConfig[name] = []Hop{&docker}
			} else {
				return nil, fmt.Errorf(
					"There's no definition of docker for %v", name)
			}
		}
	}
	return hopsConfig, nil
}
func (sd *sortableDistroByNumStaticHost) Less(i, j int) bool {
	if sd.distros[i].Provider != evergreen.HostTypeStatic &&
		sd.distros[j].Provider != evergreen.HostTypeStatic {
		return false
	}
	if sd.distros[i].Provider == evergreen.HostTypeStatic &&
		sd.distros[j].Provider != evergreen.HostTypeStatic {
		return true
	}
	if sd.distros[i].Provider != evergreen.HostTypeStatic &&
		sd.distros[j].Provider == evergreen.HostTypeStatic {
		return false
	}

	h1 := &static.Settings{}
	h2 := &static.Settings{}

	err := mapstructure.Decode(sd.distros[i].ProviderSettings, h1)
	if err != nil {
		return false
	}

	err = mapstructure.Decode(sd.distros[j].ProviderSettings, h2)
	if err != nil {
		return false
	}

	return len(h1.Hosts) > len(h2.Hosts)
}
Exemple #9
0
func (p *PostProcessor) Configure(raws ...interface{}) error {
	// Store the raw configs for usage later
	p.rawConfigs = raws

	for _, raw := range raws {
		err := mapstructure.Decode(raw, &p.config)
		if err != nil {
			return err
		}
	}

	ppExtraConfig := make(map[string]interface{})
	if p.config.OutputPath == "" {
		p.config.OutputPath = "packer_{{ .BuildName }}_{{.Provider}}.box"
		ppExtraConfig["output"] = p.config.OutputPath
	}

	_, err := template.New("output").Parse(p.config.OutputPath)
	if err != nil {
		return fmt.Errorf("output invalid template: %s", err)
	}

	// Store the extra configuration for post-processors
	p.rawConfigs = append(p.rawConfigs, ppExtraConfig)

	// TODO(mitchellh): Properly handle multiple raw configs
	var mapConfig map[string]interface{}
	if err := mapstructure.Decode(raws[0], &mapConfig); err != nil {
		return err
	}

	p.premade = make(map[string]packer.PostProcessor)
	errors := make([]error, 0)
	for k, raw := range mapConfig {
		pp := keyToPostProcessor(k)
		if pp == nil {
			continue
		}

		// Create the proper list of configurations
		ppConfigs := make([]interface{}, 0, len(p.rawConfigs)+1)
		copy(ppConfigs, p.rawConfigs)
		ppConfigs = append(ppConfigs, raw)

		if err := pp.Configure(ppConfigs...); err != nil {
			errors = append(errors, err)
		}

		p.premade[k] = pp
	}

	if len(errors) > 0 {
		return &packer.MultiError{errors}
	}

	return nil
}
func (h *GenericHandler) Handle(event model.WatchEvent) error {

	if i, ok := event.Object.(map[string]interface{}); ok {
		var metadata *model.ObjectMeta
		var kind string
		var selector map[string]interface{}
		if h.kindHandled == RCKind {
			var rc model.ReplicationController
			mapstructure.Decode(i, &rc)
			kind = rc.Kind
			selector = rc.Spec.Selector
			metadata = rc.Metadata
		} else if h.kindHandled == ServiceKind {
			var svc model.Service
			mapstructure.Decode(i, &svc)
			kind = svc.Kind
			selector = svc.Spec.Selector
			metadata = svc.Metadata
		} else {
			return fmt.Errorf("Unrecognized handled kind [%s].", h.kindHandled)
		}

		ts, err := time.Parse(time.RFC3339, metadata.CreationTimestamp)
		if err != nil {
			return err
		}

		serviceEvent := &client.ServiceEvent{
			Name:              metadata.Name,
			ExternalId:        metadata.Uid,
			EventType:         constructEventType(event),
			ResourceType:      constructResourceType(kind),
			ExternalTimestamp: ts.Unix(),
		}

		switch event.Type {
		case "MODIFIED":
			fallthrough

		case "ADDED":
			err = h.add(selector, metadata, event, serviceEvent, serviceEvent.ResourceType)
			if err != nil {
				return err
			}

		case "DELETED":
			// No extra fields required for delete
		default:
			return nil
		}

		_, err = h.rancherClient.ServiceEvent.Create(serviceEvent)
		return err

	}
	return fmt.Errorf("Couldn't decode event [%#v]", event)
}
Exemple #11
0
// LoadBlocks will load the blocks that are stored in the raw_blocks data and
// mix it up with the user input that we give it.
func (t *JsonTemplate) LoadBlocks(user_input interface{}) {
	var blocks []map[string]interface{}
	var input map[string]interface{}
	mapstructure.Decode(t.raw_block_data, &blocks)
	mapstructure.Decode(user_input, &input)

	for _, block := range blocks {
		t.blocks = append(t.blocks, t.LoadBlock(block, input))
	}

	t.wg.Wait()
}
Exemple #12
0
func Start(orientChan chan orient.Event, shootChan chan shoot.Event) {
	port := 4242

	var upgrader = websocket.Upgrader{
		ReadBufferSize:  2048,
		WriteBufferSize: 2048,
		CheckOrigin: func(r *http.Request) bool {
			return true
		},
	}

	http.HandleFunc("/control", func(w http.ResponseWriter, r *http.Request) {
		log.Debug("Connection received")
		conn, err := upgrader.Upgrade(w, r, nil)
		if err != nil {
			log.Fatal(err)
		}

		defer conn.Close()

		for {
			messageType, reader, err := conn.NextReader()
			if err != nil {
				log.Println(err)
				return
			}
			if messageType == websocket.TextMessage {
				packet := Packet{}
				decoder := json.NewDecoder(reader)
				if err := decoder.Decode(&packet); err != nil {
					log.Warning(err)
					continue
				}

				switch packet.Type {
				case "orient":
					event := orient.Event{}
					mapstructure.Decode(packet.Payload, &event)
					orientChan <- event
				case "shoot":
					event := shoot.Event{}
					mapstructure.Decode(packet.Payload, &event)
					shootChan <- event
				default:
					log.Info("Oops unknown packet: ", packet)
				}
			}
		}
	})

	go http.ListenAndServe(fmt.Sprintf("0.0.0.0:%d", port), nil)
	log.Infof("Websocket server started on port %d", port)
}
Exemple #13
0
func testCredsWrite(t *testing.T, roleName string, data map[string]interface{}, expectError bool) logicaltest.TestStep {
	return logicaltest.TestStep{
		Operation: logical.WriteOperation,
		Path:      fmt.Sprintf("creds/%s", roleName),
		Data:      data,
		ErrorOk:   true,
		Check: func(resp *logical.Response) error {
			if resp == nil {
				return fmt.Errorf("response is nil")
			}
			if resp.Data == nil {
				return fmt.Errorf("data is nil")
			}
			if expectError {
				var e struct {
					Error string `mapstructure:"error"`
				}
				if err := mapstructure.Decode(resp.Data, &e); err != nil {
					return err
				}
				if len(e.Error) == 0 {
					return fmt.Errorf("expected error, but write succeeded.")
				}
				return nil
			}
			if roleName == testDynamicRoleName {
				var d struct {
					Key string `mapstructure:"key"`
				}
				if err := mapstructure.Decode(resp.Data, &d); err != nil {
					return err
				}
				if d.Key == "" {
					return fmt.Errorf("Generated key is an empty string")
				}
				// Checking only for a parsable key
				_, err := ssh.ParsePrivateKey([]byte(d.Key))
				if err != nil {
					return fmt.Errorf("Generated key is invalid")
				}
			} else {
				if resp.Data["key_type"] != KeyTypeOTP {
					return fmt.Errorf("Incorrect key_type")
				}
				if resp.Data["key"] == nil {
					return fmt.Errorf("Invalid key")
				}
			}
			return nil
		},
	}
}
Exemple #14
0
// APISave returns true if the file is local only
func (parser *Parser) APISave(payloads []*get3w.SavePayload) error {
	for _, payload := range payloads {
		switch payload.Type {
		case get3w.PayloadTypeConfig:
			if payload.Status == get3w.PayloadStatusModified || payload.Status == get3w.PayloadStatusAdded {
				var config get3w.Config
				if err := mapstructure.Decode(payload.Data, &config); err != nil {
					return err
				}
				parser.Config = &config
				if err := parser.WriteConfig(); err != nil {
					return err
				}
			}

		case get3w.PayloadTypePage:
			if payload.Status == get3w.PayloadStatusModified || payload.Status == get3w.PayloadStatusAdded {
				var page get3w.Page
				if err := mapstructure.Decode(payload.Data, &page); err != nil {
					return err
				}
				if err := parser.WritePage(&page); err != nil {
					return err
				}
			}

		case get3w.PayloadTypeSection:
			if payload.Status == get3w.PayloadStatusModified || payload.Status == get3w.PayloadStatusAdded {
				var section get3w.Section
				if err := mapstructure.Decode(payload.Data, &section); err != nil {
					return err
				}
				if err := parser.saveSection(&section); err != nil {
					return err
				}
			} else if payload.Status == get3w.PayloadStatusRemoved {
				var section get3w.Section
				if err := mapstructure.Decode(payload.Data, &section); err != nil {
					return err
				}
				if err := parser.deleteSection(section.Path); err != nil {
					return err
				}
			}

		}
	}
	return nil
}
func (s *SourceOptionsSlice) UnmarshalJSON(data []byte) error {
	var maps []map[string]interface{}

	err := json.Unmarshal(data, &maps)
	if err != nil {
		return bosherr.WrapError(err, "Unmarshalling sources")
	}

	for _, m := range maps {
		if optType, ok := m["Type"]; ok {
			var err error
			var opts SourceOptions

			switch {
			case optType == "HTTP":
				var o HTTPSourceOptions
				err, opts = mapstruc.Decode(m, &o), o

			case optType == "InstanceMetadata":
				var o InstanceMetadataSourceOptions
				err, opts = mapstruc.Decode(m, &o), o

			case optType == "ConfigDrive":
				var o ConfigDriveSourceOptions
				err, opts = mapstruc.Decode(m, &o), o

			case optType == "File":
				var o FileSourceOptions
				err, opts = mapstruc.Decode(m, &o), o

			case optType == "CDROM":
				var o CDROMSourceOptions
				err, opts = mapstruc.Decode(m, &o), o

			default:
				err = bosherr.Errorf("Unknown source type '%s'", optType)
			}

			if err != nil {
				return bosherr.WrapErrorf(err, "Unmarshalling source type '%s'", optType)
			}
			*s = append(*s, opts)
		} else {
			return bosherr.Error("Missing source type")
		}
	}

	return nil
}
Exemple #16
0
// marshal merges config a and b and decodes the merge config into the provided
// structure.
func marshal(a Config, b Config, rawVal interface{}) (err error) {
	err = mapstructure.Decode(&a, rawVal)
	if err != nil {
		return
	}

	if b != nil {
		err = mapstructure.Decode(&b, rawVal)
		if err != nil {
			return
		}
	}

	return
}
Exemple #17
0
// Marshals the config into a Struct
func Marshal(rawVal interface{}) (err error) {
	err = mapstructure.Decode(defaults, rawVal)
	if err != nil {
		return
	}
	err = mapstructure.Decode(config, rawVal)
	if err != nil {
		return
	}
	err = mapstructure.Decode(override, rawVal)
	if err != nil {
		return
	}
	return
}
Exemple #18
0
func (p *PostProcessor) Configure(raws ...interface{}) error {
	for _, raw := range raws {
		err := mapstructure.Decode(raw, &p.config)
		if err != nil {
			return err
		}
	}

	if p.config.OutputPath == "" {
		p.config.OutputPath = "packer_{{ .BuildName }}_{{.Provider}}.box"
	}

	_, err := template.New("output").Parse(p.config.OutputPath)
	if err != nil {
		return fmt.Errorf("output invalid template: %s", err)
	}

	// TODO(mitchellh): Properly handle multiple raw configs
	var mapConfig map[string]interface{}
	if err := mapstructure.Decode(raws[0], &mapConfig); err != nil {
		return err
	}

	packerConfig := map[string]interface{}{
		packer.BuildNameConfigKey: p.config.PackerBuildName,
	}

	p.premade = make(map[string]packer.PostProcessor)
	errors := make([]error, 0)
	for k, raw := range mapConfig {
		pp := keyToPostProcessor(k)
		if pp == nil {
			continue
		}

		if err := pp.Configure(raw, packerConfig); err != nil {
			errors = append(errors, err)
		}

		p.premade[k] = pp
	}

	if len(errors) > 0 {
		return &packer.MultiError{errors}
	}

	return nil
}
Exemple #19
0
func testAccStepReadRole(t *testing.T, name string, sql string) logicaltest.TestStep {
	return logicaltest.TestStep{
		Operation: logical.ReadOperation,
		Path:      "roles/" + name,
		Check: func(resp *logical.Response) error {
			if resp == nil {
				if sql == "" {
					return nil
				}

				return fmt.Errorf("bad: %#v", resp)
			}

			var d struct {
				SQL string `mapstructure:"sql"`
			}
			if err := mapstructure.Decode(resp.Data, &d); err != nil {
				return err
			}

			if d.SQL != sql {
				return fmt.Errorf("bad: %#v", resp)
			}

			return nil
		},
	}
}
Exemple #20
0
// ExtractListeners accepts a Page struct, specifically a ListenerPage struct,
// and extracts the elements into a slice of Listener structs. In other words,
// a generic collection is mapped into a relevant slice.
func ExtractListeners(page pagination.Page) ([]Listener, error) {
	var resp struct {
		Listeners []Listener `mapstructure:"listeners" json:"listeners"`
	}
	err := mapstructure.Decode(page.(ListenerPage).Body, &resp)
	return resp.Listeners, err
}
Exemple #21
0
func testAccStepConfig(t *testing.T, d map[string]interface{}, expectError bool) logicaltest.TestStep {
	return logicaltest.TestStep{
		Operation: logical.UpdateOperation,
		Path:      "config/connection",
		Data:      d,
		ErrorOk:   true,
		Check: func(resp *logical.Response) error {
			if expectError {
				if resp.Data == nil {
					return fmt.Errorf("data is nil")
				}
				var e struct {
					Error string `mapstructure:"error"`
				}
				if err := mapstructure.Decode(resp.Data, &e); err != nil {
					return err
				}
				if len(e.Error) == 0 {
					return fmt.Errorf("expected error, but write succeeded.")
				}
				return nil
			} else if resp != nil {
				return fmt.Errorf("response should be nil")
			}
			return nil
		},
	}
}
Exemple #22
0
// FromParameters constructs a new Driver with a given parameters map
// Required parameters:
// - username
// - password
// - authurl
// - container
func FromParameters(parameters map[string]interface{}) (*Driver, error) {
	params := Parameters{
		ChunkSize:          defaultChunkSize,
		InsecureSkipVerify: false,
	}

	if err := mapstructure.Decode(parameters, &params); err != nil {
		return nil, err
	}

	if params.Username == "" {
		return nil, fmt.Errorf("No username parameter provided")
	}

	if params.Password == "" {
		return nil, fmt.Errorf("No password parameter provided")
	}

	if params.AuthURL == "" {
		return nil, fmt.Errorf("No authurl parameter provided")
	}

	if params.Container == "" {
		return nil, fmt.Errorf("No container parameter provided")
	}

	if params.ChunkSize < minChunkSize {
		return nil, fmt.Errorf("The chunksize %#v parameter should be a number that is larger than or equal to %d", params.ChunkSize, minChunkSize)
	}

	return New(params)
}
Exemple #23
0
func (p *Page) getRenderingConfig() *helpers.Blackfriday {

	p.renderingConfigInit.Do(func() {
		pageParam := p.GetParam("blackfriday")
		siteParam := viper.GetStringMap("blackfriday")

		combinedParam := siteParam

		if pageParam != nil {
			combinedParam = make(map[string]interface{})

			for k, v := range siteParam {
				combinedParam[k] = v
			}

			pageConfig := cast.ToStringMap(pageParam)

			for key, value := range pageConfig {
				combinedParam[key] = value
			}
		}
		p.renderingConfig = helpers.NewBlackfriday()
		if err := mapstructure.Decode(combinedParam, p.renderingConfig); err != nil {
			jww.FATAL.Printf("Failed to get rendering config for %s:\n%s", p.BaseFileName(), err.Error())
		}
	})

	return p.renderingConfig
}
Exemple #24
0
func testAccStepReadPolicy(t *testing.T, name string, value string) logicaltest.TestStep {
	return logicaltest.TestStep{
		Operation: logical.ReadOperation,
		Path:      "roles/" + name,
		Check: func(resp *logical.Response) error {
			if resp == nil {
				if value == "" {
					return nil
				}

				return fmt.Errorf("bad: %#v", resp)
			}

			var d struct {
				Policy string `mapstructure:"policy"`
			}
			if err := mapstructure.Decode(resp.Data, &d); err != nil {
				return err
			}

			if d.Policy != value {
				return fmt.Errorf("bad: %#v", resp)
			}

			return nil
		},
	}
}
Exemple #25
0
// ParseENV parse environment only
func (c *FlagEnv) ParseENV(v interface{}) error {
	data := make(map[string]interface{})
	for camelName, f := range c.flags {
		switch f.flagType {
		case stringFlag:
			data[camelName] = ENVString(f.envName, f.defStr)
		case stringSliceFlag:
			data[camelName] = ENVStringSlice(f.name, f.defStrSlice)
		case intFlag:
			data[camelName] = ENVInt(f.name, f.defInt)
		case intSliceFlag:
			data[camelName] = ENVIntSlice(f.name, f.defIntSlice)
		case float64Flag:
			data[camelName] = ENVFloat64(f.name, f.defFloat64)
		case boolFlag:
			data[camelName] = ENVBool(f.name, f.defBool)
		case durationFlag:
			data[camelName] = ENVDuration(f.name, f.defDuration)
		}
	}

	mapstructure.Decode(data, v)

	return nil
}
Exemple #26
0
// See the CloudServersProvider interface for details.
func (gsp *genericServersProvider) ServerById(id string) (*Server, error) {
	var s *Server

	err := gsp.context.WithReauth(gsp.access, func() error {
		url := gsp.endpoint + "/servers/" + id
		return perigee.Get(url, perigee.Options{
			Results: &struct{ Server **Server }{&s},
			MoreHeaders: map[string]string{
				"X-Auth-Token": gsp.access.AuthToken(),
			},
			OkCodes: []int{200},
		})
	})

	// Compatibility with v0.0.x -- we "map" our public and private
	// addresses into a legacy structure field for the benefit of
	// earlier software.

	if err != nil {
		return s, err
	}

	err = mapstructure.Decode(s.RawAddresses, &s.Addresses)

	return s, err
}
Exemple #27
0
// See the CloudServersProvider interface for details.
func (gcp *genericServersProvider) ListServers() ([]Server, error) {
	var ss []Server

	err := gcp.context.WithReauth(gcp.access, func() error {
		url := gcp.endpoint + "/servers/detail"
		return perigee.Get(url, perigee.Options{
			CustomClient: gcp.context.httpClient,
			Results:      &struct{ Servers *[]Server }{&ss},
			MoreHeaders: map[string]string{
				"X-Auth-Token": gcp.access.AuthToken(),
			},
		})
	})

	// Compatibility with v0.0.x -- we "map" our public and private
	// addresses into a legacy structure field for the benefit of
	// earlier software.

	if err != nil {
		return ss, err
	}

	for _, s := range ss {
		err = mapstructure.Decode(s.RawAddresses, &s.Addresses)
		if err != nil {
			return ss, err
		}
	}

	return ss, err
}
Exemple #28
0
// Extract will retrieve a Config resource from an operation result.
func (r commonResult) Extract() (*Config, error) {
	if r.Err != nil {
		return nil, r.Err
	}

	var response struct {
		Config Config `mapstructure:"configuration"`
	}

	err := mapstructure.Decode(r.Body, &response)
	val := r.Body.(map[string]interface{})["configuration"].(map[string]interface{})

	if t, ok := val["created"].(string); ok && t != "" {
		creationTime, err := time.Parse(time.RFC3339, t)
		if err != nil {
			return &response.Config, err
		}
		response.Config.Created = creationTime
	}

	if t, ok := val["updated"].(string); ok && t != "" {
		updatedTime, err := time.Parse(time.RFC3339, t)
		if err != nil {
			return &response.Config, err
		}
		response.Config.Updated = updatedTime
	}

	return &response.Config, err
}
// LoadAuthorize gets authorization data with given code
func (s *RethinkDBStorage) LoadAuthorize(code string) (*osin.AuthorizeData, error) {
	result, err := r.Table(authorizeTable).Filter(r.Row.Field("Code").Eq(code)).Run(s.session)
	if err != nil {
		return nil, err
	}
	defer result.Close()

	var dataMap map[string]interface{}
	err = result.One(&dataMap)
	if err != nil {
		return nil, err
	}

	var client osin.Client
	clientID := dataMap["Client"].(map[string]interface{})["Id"].(string)
	client, err = s.GetClient(clientID)
	if err != nil {
		return nil, err
	}
	dataMap["Client"] = client

	var dataStruct osin.AuthorizeData
	err = mapstructure.Decode(dataMap, &dataStruct)
	if err != nil {
		return nil, err
	}

	return &dataStruct, nil
}
Exemple #30
0
// Parse parse environment and flag
func (c *FlagEnv) Parse(v interface{}) error {
	c.parseCli()
	c.cliApp.Before = func(context *cli.Context) error {
		data := make(map[string]interface{})
		for camelName, f := range c.flags {
			switch f.flagType {
			case stringFlag:
				data[camelName] = context.String(f.name)
			case stringSliceFlag:
				data[camelName] = context.StringSlice(f.name)
			case intFlag:
				data[camelName] = context.Int(f.name)
			case intSliceFlag:
				data[camelName] = context.IntSlice(f.name)
			case float64Flag:
				data[camelName] = context.Float64(f.name)
			case boolFlag:
				data[camelName] = context.Bool(f.name)
			case durationFlag:
				data[camelName] = context.Duration(f.name)
			}
		}

		mapstructure.Decode(data, v)

		return nil
	}

	c.cliApp.RunAndExitOnError()

	return nil
}