Exemplos de GetDefaultConfig em Golang

Exemplo n.º 1

Arquivo: unbind_service.go Projeto: diatmpravin/gagan

// DeleteParticularServiceBinding unbind a service with particular app
func DeleteParticularServiceBinding(w http.ResponseWriter, r *http.Request) {
	render := &api.Render{r, w}
	config := configuration.GetDefaultConfig()
	if err := json.NewDecoder(r.Body).Decode(&config); err != nil {
		http.Error(w, err.Error(), http.StatusBadRequest)
	}

	appName := r.URL.Query().Get("app")
	instanceName := r.URL.Query().Get("service")

	bindRepo := UnbindService{}
	app, err := bindRepo.appRepo.FindByName(config, appName)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
	}

	instance, err := bindRepo.serviceRepo.FindInstanceByName(config, instanceName)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
	}

	log.Printf("Unbinding service %s to %s...", instance.Name, app.Name)
	err = bindRepo.serviceRepo.UnbindService(config, instance, app)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
	}

	log.Printf("Service details: %+v", config)
	render.JSON(config)
}

Exemplo n.º 2

Arquivo: list_all_organizations.go Projeto: diatmpravin/gagan

func (o OrganizationList) Run(w http.ResponseWriter, r *http.Request) {
	render := &api.Render{r, w}

	config := configuration.GetDefaultConfig()

	session := configuration.Session{}

	if err := json.NewDecoder(r.Body).Decode(&session); err != nil {
		http.Error(w, err.Error(), http.StatusBadRequest)
	}

	c := configuration.RedisConnect()
	defer c.Close()

	reply, err := c.Do("GET", "user:"******"List of organizations: %+v", orgs)
	render.JSON(orgs)
}

Exemplo n.º 3

Arquivo: creating_an_app.go Projeto: diatmpravin/gagan

// CreatingAnApp will create app
func CreatingAnApp(w http.ResponseWriter, r *http.Request) {
	render := &api.Render{r, w}

	config := configuration.GetDefaultConfig()
	if err := json.NewDecoder(r.Body).Decode(&config); err != nil {
		http.Error(w, err.Error(), http.StatusBadRequest)
	}

	appName := r.URL.Query().Get("appname")
	repo := api.CloudControllerApplicationRepository{}

	app, err := repo.FindByName(config, appName)

	if err != nil {
		app, err = createApp(config, appName)

		if err != nil {
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
	}

	// TODO, need to implement
	// err = repo.Upload(config, app)
	// if err != nil {
	// 	http.Error(w, err.Error(), http.StatusInternalServerError)
	// 	return
	// }

	log.Printf("App details: %+v", app)
	render.JSON(app)
}

Exemplo n.º 4

Arquivo: user.go Projeto: diatmpravin/gagan

// PutPerson get user token from CC
func (l Login) PutUser(u *User) (config *configuration.Configuration, err error) {
	config = configuration.GetDefaultConfig()

	response, err := api.Authenticate(config.AuthorizationEndpoint, u.Email, u.Password)
	if err != nil {
		return
	}

	config.AccessToken = fmt.Sprintf("%s %s", response.TokenType, response.AccessToken)
	return
}

Exemplo n.º 5

Arquivo: retrieve_particular_app_usage_event.go Projeto: diatmpravin/gagan

func (a *AppEvents) GetRequirements(reqFactory requirements.Factory, w http.ResponseWriter, r *http.Request) (reqs []Requirement, config *configuration.Configuration, err error) {
	config = configuration.GetDefaultConfig()
	if err := json.NewDecoder(r.Body).Decode(&config); err != nil {
		http.Error(w, err.Error(), http.StatusBadRequest)
	}

	a.config = config

	appName := r.URL.Query().Get("appname")
	a.appReq = reqFactory.NewApplicationRequirement(appName)

	reqs = []Requirement{&a.appReq}
	return
}

Exemplo n.º 6

Arquivo: spaces.go Projeto: diatmpravin/gagan

// ListAllSpaces Get list of all spaces
func ListAllSpaces(w http.ResponseWriter, r *http.Request) {
	render := &Render{r, w}

	config := configuration.GetDefaultConfig()
	if err := json.NewDecoder(r.Body).Decode(&config); err != nil {
		http.Error(w, err.Error(), http.StatusBadRequest)
	}

	repo := CloudControllerSpaceRepository{}
	spaces, err := repo.FindAllSpaces(config)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	log.Printf("List of spaces: %+v", spaces)
	render.JSON(spaces)
}

Exemplo n.º 7

Arquivo: creating_service_instance.go Projeto: diatmpravin/gagan

// CreatingServiceInstance create a service instance
func CreatingServiceInstance(w http.ResponseWriter, r *http.Request) {
	render := &api.Render{r, w}

	config := configuration.GetDefaultConfig()
	if err := json.NewDecoder(r.Body).Decode(&config); err != nil {
		http.Error(w, err.Error(), http.StatusBadRequest)
	}

	name := r.URL.Query().Get("name")
	offeringName := r.URL.Query().Get("offering")
	planName := r.URL.Query().Get("plan")

	serviceRepo := api.CloudControllerServiceRepository{}
	offerings, err := serviceRepo.GetServiceOfferings(config)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
	}

	offering, err := findOffering(offerings, offeringName)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
	}

	plan, err := findPlan(offering.Plans, planName)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
	}

	log.Printf("Creating service %s", name)
	err = serviceRepo.CreateServiceInstance(config, name, plan)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
	}

	// TODO, find service by name and send json response
	log.Printf("Service details: %+v", config)
	render.JSON(config)
}

Exemplo n.º 8

Arquivo: handlers.go Projeto: diatmpravin/aakash

package api

import (
	"github.com/diatmpravin/gagan/api"
	"github.com/diatmpravin/gagan/commands"
	"github.com/diatmpravin/gagan/configuration"
	"github.com/diatmpravin/gagan/requirements"
	"net/http"
	"strings"
	"text/template"
)

// var configRepo = configuration.NewConfigurationDiskRepository()
var config = configuration.GetDefaultConfig()

var repoLocator = api.NewRepositoryLocator(config)
var cmdFactory = commands.NewFactory(repoLocator)

var reqFactory = requirements.NewFactory(repoLocator)
var cmdRunner = commands.NewRunner(reqFactory)

// custom template delimiters since the Go default delimiters clash
// with Angular's default.
var templateDelims = []string{"{{%", "%}}"}

func LoginHandler(w http.ResponseWriter, r *http.Request) {
	t := template.New("login.html")
	t.Delims(templateDelims[0], templateDelims[1])
	t.ParseFiles("web/pages/login.html")
	t.Execute(w, t)
}