func (a *BasicController) Set(rw http.ResponseWriter, req *http.Request) {
decoder := json.NewDecoder(req.Body)
var app entity.EtcdBaseModel
err := decoder.Decode(&app)
if err != nil {
http.Error(rw, err.Error(), http.StatusBadRequest)
return
}
vars := mux.Vars(req)
if a.setValidation(app, vars) != true {
log.Warn("Post Instance: Set validation fail")
http.Error(rw, "Post Instance: Set validation fail", http.StatusBadRequest)
return
}
var ttl string = req.FormValue("ttl")
if ttl == "" {
ttl = a.defaultTTL
}
err = a.GetConfiguredRepository(vars).Set(&app, ttl, rw, req)
if err != nil {
http.Error(rw, err.Error(), http.StatusInternalServerError)
return
}
}
func (a *BasicController) Get(rw http.ResponseWriter, req *http.Request) {
vars := mux.Vars(req)
id := vars["id"]
app, err := a.GetConfiguredRepository(vars).Get(id)
// TODO: Implement Balancer Middleware
if err != nil {
http.Error(rw, err.Error(), http.StatusNotFound)
return
}
jsonOutput, err := json.Marshal(app)
if err != nil {
http.Error(rw, err.Error(), http.StatusInternalServerError)
return
}
rw.WriteHeader(http.StatusOK)
rw.Header().Set("Content-Type", "application/json")
rw.Write(jsonOutput)
}
func (a *BasicController) List(rw http.ResponseWriter, req *http.Request) {
vars := mux.Vars(req)
apps, err := a.GetConfiguredRepository(vars).GetAll()
if err != nil {
http.Error(rw, err.Error(), http.StatusNotFound)
return
}
jsonOutput, err := json.Marshal(apps)
if err != nil {
http.Error(rw, err.Error(), http.StatusInternalServerError)
return
}
rw.Header().Set("Content-Type", "application/json")
// allow cross domain AJAX requests
rw.Header().Set("Access-Control-Allow-Origin", "*")
rw.Header().Set("Access-Control-Allow-Headers", "Content-Type, Authorization, Content-Length, X-Requested-With")
// TODO: Add Allow-Methods
rw.WriteHeader(http.StatusOK)
rw.Write(jsonOutput)
}
func (b *BalancedInstancesController) Get(rw http.ResponseWriter, req *http.Request) {
vars := mux.Vars(req)
appId := vars["id"]
app, err := b.repo.Get(appId)
// log.Printf("Repo Get Request %#v", map[string]interface{}(*app))
if err != nil {
http.Error(rw, err.Error(), http.StatusNotFound)
return
}
appEntity, err := NewApplicationFromEtcdBaseModel(app)
if err != nil {
http.Error(rw, err.Error(), http.StatusInternalServerError)
return
}
// log.Printf("appEntity: %#v", appEntity)
// log.Printf("appEntity.Balancers: %#v", appEntity.Balancers)
var jsonOutput []byte = []byte("[]")
if len(appEntity.Balancers) > 0 {
balancers, err := json.Marshal(appEntity.Balancers)
if err != nil {
log.Println("Bad format for Balancers")
http.Error(rw, err.Error(), http.StatusInternalServerError)
return
}
activeInstances := b.getActiveInstances(appEntity.Instances)
if len(activeInstances) > 0 {
instances, err := json.Marshal(activeInstances)
if err != nil {
log.Println("Bad format for Instances")
http.Error(rw, err.Error(), http.StatusInternalServerError)
return
}
response := b.sendZMQRequestToBalancer([]byte(appEntity.Id), [][]byte{balancers, instances})
log.Println("++++++++++++++++++ ZMQ RESPONSE ++++++++++++++++++")
// log.Printf("%#v", response)
// TODO: process response
if len(response) > 0 {
jsonOutput = response[0]
} else {
log.Println("Zeromq request timeout expired")
http.Error(rw, "Zeromq request timeout expired", http.StatusInternalServerError)
return
}
} else {
jsonOutput = []byte("[]")
}
} else {
activeInstances := b.getActiveInstances(appEntity.Instances)
sortedInstanceUris := make([]string, 0)
for _, instance := range activeInstances {
sortedInstanceUris = append(sortedInstanceUris, instance.Info["uri"].(string))
}
jsonOutput, _ = json.Marshal(sortedInstanceUris)
}
rw.WriteHeader(http.StatusOK)
rw.Header().Set("Content-Type", "application/json")
rw.Write(jsonOutput)
}
