Esempio n. 1
0
func createNewJSONConfig(filename string) {
	newConfig := gabs.New()
	newConfig.SetP(false, "meta.admin")
	newConfig.SetP("https://api.civo.com", "meta.url")
	newConfig.SetP("1", "meta.version")
	ioutil.WriteFile(filename, []byte(newConfig.StringIndent("", "  ")), 0600)
}
Esempio n. 2
0
func getConfig(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Content-Type", "application/json")
	json := gabs.New()
	json.Set(readonly == "true", "readonly")

	w.Write([]byte(json.String()))
}
Esempio n. 3
0
func (a *RawAdapter) Stream(logstream chan *router.Message) {
	msg := gabs.New()
	for message := range logstream {
		buf := new(bytes.Buffer)
		err := a.tmpl.Execute(buf, message)
		if err != nil {
			log.Debug("raw:", err)
			return
		}

		if cn := utils.M1[message.Container.Name]; cn != "" {
			//logmsg := utils.SendMessage(cn, buf.String(), message.Container)
			//_, err = connection.Write([]byte(logmsg))
			utils.SendMessage(cn, buf.String(), message.Container.ID, msg)
			_, err = connection.Write(append([]byte(msg.String()), '\n'))
			if err != nil {
				log.Error("raw:", err, reflect.TypeOf(a.conn).String())
				/*if reflect.TypeOf(a.conn).String() != "*net.TCPConn"{
					return
				}*/
			}
		}
	}

}
Esempio n. 4
0
File: cli.go Progetto: shiwano/musta
func createJSONContainer(jsonString string) *gabs.Container {
	if jsonString == "" {
		return gabs.New()
	}

	container, err := gabs.ParseJSON([]byte(jsonString))
	if err != nil {
		Fatalf("Failed to parse piped JSON string: %s", err)
	}

	return container
}
Esempio n. 5
0
func persistenCounter() {
	if len(counter) > 0 {
		json := gabs.New()
		counterlock.Lock()
		for k, v := range counter {
			json.Set(v, k)
		}
		counterlock.Unlock()
		err := ioutil.WriteFile(countFile, json.Bytes(), 0x644)
		if err != nil {
			log.Error("persisten counter failed: ", err)
		}
	}
}
func UpdateJsonFile(file string, paths []string, value interface{}, ui packer.Ui, force bool) error {

	// TODO: add a flag to create a file if it does not exist
	content, err := ioutil.ReadFile(file)
	if err != nil {
		return err
	}

	// Parse file and create new JSON object if invalid detected and overwrite
	json, err := gabs.ParseJSON(content)
	if err != nil {
		ui.Say("Invalid JSON Template")
		if force {
			json = gabs.New()
		} else {
			return err
		}
	}

	if newValueMap, success := value.(map[string]string); success {
		for _, path := range paths {
			oldValue, _ := json.Path(path).Data().(string)
			ui.Say(fmt.Sprintf("Updating %s from %s to %s in %s...", path, oldValue, newValueMap, file))
			for key, value := range newValueMap {
				ui.Say(fmt.Sprintf("[DEBUG] Setting %s to %s at %s", key, value, path))
				// TODO: this is pretty brittle here since if the type of value of node
				// is not changeable. This might lead to bad render of JSON where previously
				// erroreous values are prevailed over consecutive runs.
				json.Set("", path, key)
				json.Set(value, path, key)
				ui.Say(fmt.Sprintf("[DEBUG] JSON Dump %s", json.String()))

			}
		}
	} else {
		newValue, _ := value.(string)
		for _, path := range paths {
			oldValue, _ := json.Path(path).Data().(string)
			ui.Say(fmt.Sprintf("Updating %s from %s to %s in %s...", path, oldValue, newValue, file))
			ui.Say(fmt.Sprintf("%s", path))
			json.SetP(newValue, path)
		}
	}
	// pretty printed JSON dump
	err = ioutil.WriteFile(file, []byte(json.StringIndent("", "    ")), 0644)
	return err
}
Esempio n. 7
0
func (m *Maropost) GetContactsByList(list string, page string) (*gabs.Container, error) {
	// Make our request
	response, err := MakeRequest(m.Account+"/lists/"+list+"/contacts.json?page="+page+"&auth_token="+m.AuthToken, "GET", nil, false)
	if err != nil {
		return nil, err
	}

	var object interface{}
	jsonDecoder := json.NewDecoder(response.Body)
	if err = jsonDecoder.Decode(&object); err != nil {
		return nil, err
	}

	jsonObject := gabs.New()
	jsonObject.SetP(object, "array")
	defer response.Body.Close()
	return jsonObject.S("array"), nil
}
Esempio n. 8
0
func (a *RawAdapter) Stream(logstream chan *router.Message) {
	msg := gabs.New()
	for message := range logstream {
		buf := new(bytes.Buffer)
		err := a.tmpl.Execute(buf, message)
		if err != nil {
			log.Error("raw:", err)
			return
		}
		if cn := utils.M1[message.Container.Name]; cn != "" {
			utils.SendMessage(cn, buf.String(), message.Container.ID, msg)
			//logmsg := utils.SendMessage(cn, buf.String(), message.Container)
			msg := &kafka.ProducerMessage{Topic: topic, Value: kafka.StringEncoder(msg.String())}
			partition, offset, err := a.producer.SendMessage(msg)
			_, _, _ = partition, offset, err
		}
	}

}
Esempio n. 9
0
func saveDoc(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Content-Type", "application/json")
	json := gabs.New()
	if readonly == "false" {
		r.ParseForm()
		path := r.Form["path"][0]
		markdown := r.Form["doc"][0]
		err := ioutil.WriteFile(path, []byte(markdown), 0644)
		if err != nil {
			json.Set(false, "success")
			json.Set(err.Error(), "error")
		} else {
			json.Set(true, "success")
		}
	} else {
		json.Set(false, "success")
		json.Set("moc is in readonly mode", "error")
	}

	w.Write([]byte(json.String()))
}
Esempio n. 10
0
// map json from player to logicserver
func mapPlayerToGlobal(db gorm.DB) *gabs.Container {
	// TODO: IMPORTANT THIS RELIES ON GAME TICK LOGIC
	var player_actions []PlayerAction

	// fetch all active entries to memory
	// ordering by game tick so only recent ones are taken
	db.Where("Stale = ?", false).Order("GameTick").Find(&player_actions)

	// update all the entries as stale in a batch
	// TODO: ideally the above two should be in a transaction
	db.Table("player_action").Where("Stale = ?", false).Updates(PlayerAction{Stale: true})

	jsonObj := gabs.New()

	// ref: https://github.com/Jeffail/gabs#generating-json
	for _, player_state := range player_actions {
		jsonObj.Set(player_state.Actions, player_state.Username, "Actions")
		jsonObj.Set(player_state.GameTick, player_state.Username, "GameTick")
	}

	return jsonObj
}
func (this Elasticsearch) statsToAtollReport(data string) (string, error) {
	statsParsed, err := gabs.ParseJSON([]byte(data))
	if err != nil {
		return "", err
	}
	atollReport := gabs.New()
	atollReport.SetP("elasticsearch", "id")
	atollReport.SetP("Elasticsearch", "name")

	// Main state
	state := "error"
	esStatus := statsParsed.S("status").Data().(string)
	if esStatus == "green" {
		state = "ok"
	} else if esStatus == "yellow" {
		state = "warn"
	}
	atollReport.SetP(state, "report.status.state")

	// Num Nodes
	atollReport.SetP(statsParsed.S("nodes").S("count").S("total").Data().(float64), "report.stats.numberOfNodes.value")

	// Core caches
	atollReport.SetP(statsParsed.S("indices").S("fielddata").S("memory_size_in_bytes").Data().(float64)/1024/1024, "report.stats.fieldDataCacheSize.value")
	atollReport.SetP([2]string{"megabytes", "memory"}, "report.stats.fieldDataCacheSize.classes")
	atollReport.SetP(statsParsed.S("indices").S("filter_cache").S("memory_size_in_bytes").Data().(float64)/1024/1024, "report.stats.filterCacheSize.value")
	atollReport.SetP([2]string{"megabytes", "memory"}, "report.stats.filterCacheSize.classes")
	atollReport.SetP(statsParsed.S("indices").S("id_cache").S("memory_size_in_bytes").Data().(float64)/1024/1024, "report.stats.idCacheSize.value")
	atollReport.SetP([2]string{"megabytes", "memory"}, "report.stats.idCacheSize.classes")

	// JVM stats
	atollReport.SetP(statsParsed.S("nodes").S("jvm").S("mem").S("heap_used_in_bytes").Data().(float64)/1024/1024, "report.stats.jvmHeapUsage.value")
	atollReport.SetP([2]string{"megabytes", "memory"}, "report.stats.jvmHeapUsage.classes")
	atollReport.SetP(statsParsed.S("nodes").S("jvm").S("mem").S("heap_max_in_bytes").Data().(float64)/1024/1024, "report.stats.jvmHeapSize.value")
	atollReport.SetP([2]string{"megabytes", "memory"}, "report.stats.jvmHeapSize.classes")

	return atollReport.String(), nil
}
Esempio n. 12
0
func (this RabbitMQ) statsToAtollReport(data string) (string, error) {
	statsParsed, err := gabs.ParseJSON([]byte(data))
	if err != nil {
		return "", err
	}
	atollReport := gabs.New()
	atollReport.SetP("rabbitmq", "id")
	atollReport.SetP("RabbitMQ", "name")

	atollReport.ArrayP("report.items")

	var children, _ = statsParsed.S("result").Children()
	for i, child := range children {
		atollReport.ArrayAppendP(map[string]interface{}{}, "report.items")
		atollItem := atollReport.S("report").S("items").Index(i)
		atollItem.SetP(child.S("name").Data().(string), "name")
		atollItem.SetP([1]string{"queue"}, "classes")

		// Queue stats
		atollItem.SetP([2]string{"memory", "bytes"}, "stats.memoryUsage.classes")
		atollItem.SetP(child.S("memory").Data().(float64), "stats.memoryUsage.value")
		atollItem.SetP([2]string{"messages", "count"}, "stats.numMessages.classes")
		atollItem.SetP(child.S("messages").Data().(float64), "stats.numMessages.value")

		publishRate := child.S("message_stats").S("publish_details").S("rate")
		if publishRate.String() != "{}" {
			atollItem.SetP([3]string{"throughput", "per-second", "average"}, "stats.publishRate.classes")
			atollItem.SetP(publishRate.Data().(float64), "stats.publishRate.value")
		}
		deliverRate := child.S("message_stats").S("deliver_get_details").S("rate")
		if deliverRate.String() != "{}" {
			atollItem.SetP([3]string{"throughput", "per-second", "average"}, "stats.deliverRate.classes")
			atollItem.SetP(deliverRate.Data().(float64), "stats.deliverRate.value")
		}
	}

	return atollReport.String(), nil
}
Esempio n. 13
0
func getJSONSchemaRecursively(obj interface{}) *gabs.Container {
	schema := gabs.New()

	switch obj.(type) {
	case []map[string]interface{}:
		objAsArray := obj.([]map[string]interface{})
		if len(objAsArray) > 0 {
			schema.Set("array", "type")
			schema.Set(getJSONSchemaRecursively(objAsArray[0]).Data(), "items")
		}
	case []interface{}:
		objAsArray := obj.([]interface{})
		if len(objAsArray) > 0 {
			schema.Set("array", "type")
			schema.Set(getJSONSchemaRecursively(objAsArray[0]).Data(), "items")
		}
	case map[string]interface{}:
		objAsMap := obj.(map[string]interface{})
		schema.Set("object", "type")
		var keys []string
		for key, v := range objAsMap {
			schema.SetP(getJSONSchemaRecursively(v).Data(), "properties."+key)
			keys = append(keys, key)
		}
		sort.Strings(keys)
		schema.Set(false, "additionalProperties")
		schema.Set(keys, "required")
	case string:
		schema.Set("string", "type")
	case bool:
		schema.Set("boolean", "type")
	default:
		schema.Set("number", "type")
	}
	return schema
}
Esempio n. 14
0
func (this MongoDB) Monitor() (string, error) {
	session, err := mgo.Dial(fmt.Sprintf("%s:%d", this.host, this.port))
	if err != nil {
		return "", err
	}

	var serverStatus serverStatusResult
	session.Run("serverStatus", &serverStatus)

	var replSetStatus replsSetStatusResult
	session.DB("admin").Run("replSetGetStatus", &replSetStatus)

	var currentOp currentOpResult
	query := bson.M{}
	coll := session.DB("admin").C("$cmd.sys.inprog")
	coll.Find(query).One(&currentOp)

	atollReport := gabs.New()
	atollReport.SetP("mongodb", "id")
	atollReport.SetP("MongoDB", "name")
	atollReport.ArrayP("report.items")

	// Main state
	state := "ok"
	if len(replSetStatus.Members) > 0 {
		for i, member := range replSetStatus.Members {
			atollReport.ArrayAppendP(map[string]interface{}{}, "report.items")
			atollItem := atollReport.S("report").S("items").Index(i)
			if member.Health != 1 {
				state = "error"
			}
			atollItem.SetP(member.Name, "name")
			atollItem.SetP([1]string{"replicaset-member"}, "classes")
			atollItem.SetP(strings.ToLower(member.StateStr), "role")
			atollItem.SetP(member.State, "stats.state.value")
			atollItem.SetP(member.Health, "stats.health.value")
			atollItem.SetP([2]string{"seconds", "duration"}, "stats.uptime.classes")
			atollItem.SetP(member.Uptime, "stats.uptime.value")
			atollItem.SetP([2]string{"miliseconds", "duration"}, "stats.ping.classes")
			atollItem.SetP(member.PingMs, "stats.ping.value")
		}
	}
	atollReport.SetP(state, "report.status.state")

	atollReport.SetP(serverStatus.Connections.Available, "report.stats.availableConnections.value")
	atollReport.SetP(serverStatus.Connections.Current, "report.stats.currentConnections.value")
	atollReport.SetP(len(currentOp.Inprog), "report.stats.numCurrentOps.value")

	var numRunningFor2Seconds uint64 = 0
	var numRunningFor10Seconds uint64 = 0
	var numRunningFor60Seconds uint64 = 0
	var totalRunningSeconds uint64 = 0
	if len(currentOp.Inprog) > 0 {
		for i, _ := range currentOp.Inprog {
			op := currentOp.Inprog[i]
			if op.SecsRunning >= 2 {
				numRunningFor2Seconds++
			}
			if op.SecsRunning >= 10 {
				numRunningFor10Seconds++
			}
			if op.SecsRunning >= 60 {
				numRunningFor60Seconds++
			}
			totalRunningSeconds = totalRunningSeconds + op.SecsRunning
			log.Printf("Op %v, %d", op, op.SecsRunning)
		}
	}

	atollReport.SetP(totalRunningSeconds, "report.stats.currentOpsTotalRunningTime.value")
	atollReport.SetP([2]string{"duration", "seconds"}, "report.stats.currentOpsTotalRunningTime.classes")
	atollReport.SetP(numRunningFor2Seconds, "report.stats.numCurrentOps2Seconds.value")
	atollReport.SetP(numRunningFor10Seconds, "report.stats.numCurrentOps10Seconds.value")
	atollReport.SetP(numRunningFor60Seconds, "report.stats.numCurrentOps60Seconds.value")

	return atollReport.String(), nil
}
Esempio n. 15
0
func SockServer(w http.ResponseWriter, r *http.Request) {

	conn, err := websocket.Upgrade(w, r, nil, 1024, 1024)
	if _, ok := err.(websocket.HandshakeError); ok {
		http.Error(w, "Not a websocket handshake", 400)
		return
	}

	db, err := gorm.Open("postgres", "user=Roman password=Roman dbname=DB1  sslmode=disable")
	if err != nil {
		log.Fatalf("error: %v\n", err)
	}
	//db.CreateTable(&MyList{})  //создаём табл
	var allToDo []MyList

	Soc_Id := atomic.AddUint64(Max_SocId, 1)
	sockCli := ClientConn{conn, Soc_Id}
	ActiveClients[Soc_Id] = sockCli

	db.DB()
	db.Order("ID").Find(&allToDo)
	jsonObj := gabs.New()
	jsonObj.Set("All_List", "Command")
	jsonObj.Set(&allToDo, "Data")
	SendMessageToSock(Soc_Id, jsonObj.String())

	for {
		_, msg, err := conn.ReadMessage()
		if err != nil {
			delete(ActiveClients, Soc_Id)
			return
		}
		var Command string
		var ok bool
		jsonParsed, err_ := gabs.ParseJSON(msg)
		if err_ != nil {
			Davay_Do_Svidaniya(Soc_Id, conn)
			return
		}
		Command, ok = jsonParsed.Path("Command").Data().(string)
		if ok == false {
			Davay_Do_Svidaniya(Soc_Id, conn)
			return
		}

		switch Command {

		case "Todo_Add":
			var Name string
			Name, ok = jsonParsed.Path("Data.Name").Data().(string)
			if ok == false {
				Davay_Do_Svidaniya(Soc_Id, conn)
				return
			}

			var todo MyList
			todo.Name = Name
			todo.IsTrue = false
			db.Create(&todo)

			jsonObj := gabs.New()
			jsonObj.Set("New_Todo", "Command")
			jsonObj.Set(&todo.ID, "Data", "ID")
			jsonObj.Set(Name, "Data", "Name")

			SendMessageToAll(jsonObj.String())

		case "Todo_Delete":
			var ID float64
			ID, ok = jsonParsed.Path("Data.ID").Data().(float64)
			if ok == false {
				Davay_Do_Svidaniya(Soc_Id, conn)
				return
			}
			db.Where("ID = ?", ID).Delete(&MyList{})

			var todo MyList
			todo.IsTrue = false

			jsonObj := gabs.New()
			jsonObj.Set("Todo_Deleted", "Command")
			jsonObj.Set(ID, "Data", "ID")

			SendMessageToAll(jsonObj.String())

		case "Todo_Check":
			var ID float64
			var Value bool
			var value_ string
			ID, ok = jsonParsed.Path("Data.ID").Data().(float64)
			if ok == false {
				Davay_Do_Svidaniya(Soc_Id, conn)
				return
			}
			value_, ok = jsonParsed.Path("Data.IsTrue").Data().(string)
			Value = ParseBool(value_)
			if ok == false {
				Davay_Do_Svidaniya(Soc_Id, conn)
				return
			}

			var my_list MyList
			db.First(&my_list, uint64(ID))
			my_list.IsTrue = Value
			db.Save(&my_list)

			jsonObj := gabs.New()
			jsonObj.Set("Todo_Checked", "Command")
			jsonObj.Set(ID, "Data", "ID")
			jsonObj.Set(value_, "Data", "IsTrue")

			SendMessageToAll(jsonObj.String())

		case "RemoveAll":
			var todo MyList
			db.Delete(&todo)

			db.Order("ID").Find(&allToDo)
			jsonObj := gabs.New()
			jsonObj.Set("All_List", "Command")
			jsonObj.Set(&allToDo, "Data")
			SendMessageToAll(jsonObj.String())
		}
	}

	conn.Close()
}