Fr10 moving to module (#11)

* Shifting to module

* Shifting to module

Author: Tusamarco

README.md

@@ -455,7 +455,111 @@ The values for the __probes__, are calculated to help you to prevent Kubernetes
 You must use them and be sure they are correctly set in your CR or all the work done will be useless. 
 
 Resources are the cpu/memory dimension you should set. You will always have a LIMIT and a REQUEST for the resources. Keep in mind that whatever will push your pod above the memory limit will IMMEDIATELY trigger the OOM killer :) not a nice thing to have. 
-  
+
+# Module
+MySQLOperatorCalculator is also available as module.
+This is it you can include it in your code and query it directly getting back objects to browse or Json.
+The example directory contains a very simple example of code on how to do it, but mainly you have to:
+```go 
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	MO "github.com/Tusamarco/mysqloperatorcalculator/src/mysqloperatorcalculator"  <----------- Import the module
+	"strconv"
+)
+
+```
+Then when you need it:
+```go
+func main() {
+var my MO.MysqlOperatorCalculator
+
+testSupportedJson(my.GetSupportedLayouts(), my)  <---------------- 
+
+testGetconfiguration(my)
+
+}
+func testSupportedJson(supported MO.Configuration, calculator MO.MysqlOperatorCalculator) {
+	output, err := json.MarshalIndent(&supported, "", "  ")
+	if err != nil {
+		print(err.Error())
+	}
+	fmt.Println(string(output))
+
+}
+```
+In the example above I get the list of all supported platform in Json format
+But the list as objects is already there in one single call:
+```go
+my.GetSupportedLayouts()
+```
+To get the full set of parameters we first need to build the request, then pass it and get back a map containing all the settings:
+```go
+func testGetconfiguration(moc MO.MysqlOperatorCalculator) {
+	var b bytes.Buffer
+	var myRequest MO.ConfigurationRequest
+	var err error
+
+	myRequest.LoadType = MO.LoadType{Id: 2}
+	myRequest.Dimension = MO.Dimension{Id: 999, Cpu: 4000, Memory: 2.5}
+	myRequest.DBType = "group_replication" //"pxc"
+	myRequest.Output = "human"             //"human"
+	myRequest.Connections = 70
+	myRequest.Mysqlversion = MO.Version{8, 0, 33}
+
+	moc.Init(myRequest)
+	error, responseMessage, families := moc.GetCalculate()
+	if error != nil {
+		print(error.Error())
+	}
+
+	if responseMessage.MType > 0 {
+		fmt.Errorf(strconv.Itoa(responseMessage.MType) + ": " + responseMessage.MName + " " + responseMessage.MText)
+	}
+	if len(families) > 0 {
+		if myRequest.Output == "json" {
+			b, err = moc.GetJSONOutput(responseMessage, myRequest, families)
+		} else {
+			b, err = moc.GetHumanOutput(responseMessage, myRequest, families)
+		}
+		if err != nil {
+			print(err.Error())
+			return
+		}
+
+		println(b.String())
+
+	}
+
+}
+```
+The first object we need to create is the ConfigurationRequest:
+```go
+	var myRequest MO.ConfigurationRequest
+```
+then we can populate it, in this case we DO NOT set a supported environment but an open scope:
+```go
+	myRequest.LoadType = MO.LoadType{Id: 2}
+	myRequest.Dimension = MO.Dimension{Id: 999, Cpu: 4000, Memory: 2.5}
+	myRequest.DBType = "group_replication" //"pxc"
+	myRequest.Output = "human"             //"human"
+	myRequest.Connections = 70
+	myRequest.Mysqlversion = MO.Version{8, 0, 33}
+```
+With DImension Id 999 we declare is going to be an open scope and after we must declare the CPU and memory.
+If instead we choose a fix and supported dimension, then the Dimension.Id and MySQL Version, will be enough.
+
+We then need to:
+```go
+	moc.Init(myRequest)
+	error, responseMessage, families := moc.GetCalculate()
+```
+Where families will be the top container of all our settings.
+We can decide if to parse it as a Map or if convert it to other formats like Json, or plain text.
+
+This is it, easy.
+
 # Final... 
 The toool is there and it needs testing and real evaluation, so I reccomand you to test, test, test whatever configuration you will get. 
 Notihing is perfect, so let me know if you find things that make no sense or not workign as expected. 

go.mod

@@ -1,8 +1,10 @@
-module mysqloperatorcalculator
+module github.com/Tusamarco/mysqloperatorcalculator
 
-
-go 1.18
+go 1.20
 
 require github.com/sirupsen/logrus v1.9.0
 
-require golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f // indirect
+require golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8 // indirect
+
+//require golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8 // indirect
+//

go.sum

@@ -8,9 +8,8 @@ github.com/sirupsen/logrus v1.9.0/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVs
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY=
 github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8 h1:0A+M6Uqn+Eje4kHMK80dtF3JCXC4ykBgQG4Fe06QRhQ=
 golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f h1:v4INt8xihDGvnrfjMDVXGxw9wrfxYyCjk0KbXjhR55s=
-golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

src/example/example.go

@@ -0,0 +1,81 @@
+package main
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	MO "github.com/Tusamarco/mysqloperatorcalculator/src/mysqloperatorcalculator"
+	"strconv"
+)
+
+func main() {
+	var my MO.MysqlOperatorCalculator
+
+	testSupportedJson(my.GetSupportedLayouts(), my)
+
+	testGetconfiguration(my)
+
+}
+
+//get all the supported platforms and dimensions as an object that you can transform or not:
+//type Configuration struct {
+//	DBType        []string      `json:"dbtype"`
+//	Dimension     []Dimension   `json:"dimension"`
+//	LoadType      []LoadType    `json:"loadtype"`
+//	Connections   []int         `json:"connections"`
+//	Output        []string      `json:"output"`
+//	Mysqlversions MySQLVersions `json:"mysqlversions"`
+//}
+
+func testSupportedJson(supported MO.Configuration, calculator MO.MysqlOperatorCalculator) {
+	output, err := json.MarshalIndent(&supported, "", "  ")
+	if err != nil {
+		print(err.Error())
+	}
+	fmt.Println(string(output))
+
+}
+
+//Get the whole set of parameters plus message as the following objects hierarchy
+//  Families->
+//          Groups -->
+//                   Parameters
+// THE VALID value in parameter to be consider as CURRENT is !!Value!!!
+
+func testGetconfiguration(moc MO.MysqlOperatorCalculator) {
+	var b bytes.Buffer
+	var myRequest MO.ConfigurationRequest
+	var err error
+
+	myRequest.LoadType = MO.LoadType{Id: 2}
+	myRequest.Dimension = MO.Dimension{Id: 999, Cpu: 4000, Memory: 2.5}
+	myRequest.DBType = "group_replication" //"pxc"
+	myRequest.Output = "human"             //"human"
+	myRequest.Connections = 70
+	myRequest.Mysqlversion = MO.Version{8, 0, 33}
+
+	moc.Init(myRequest)
+	error, responseMessage, families := moc.GetCalculate()
+	if error != nil {
+		print(error.Error())
+	}
+
+	if responseMessage.MType > 0 {
+		fmt.Errorf(strconv.Itoa(responseMessage.MType) + ": " + responseMessage.MName + " " + responseMessage.MText)
+	}
+	if len(families) > 0 {
+		if myRequest.Output == "json" {
+			b, err = moc.GetJSONOutput(responseMessage, myRequest, families)
+		} else {
+			b, err = moc.GetHumanOutput(responseMessage, myRequest, families)
+		}
+		if err != nil {
+			print(err.Error())
+			return
+		}
+
+		println(b.String())
+
+	}
+
+}

src/Global/help.go src/help.gosrc/Global/help.go renamed to src/help.go

@@ -15,7 +15,7 @@
  *
  */
 
-package Global
+package main
 
 import "fmt"
 
@@ -25,9 +25,9 @@ type HelpText struct {
 	helpShort string
 }
 
-//func (help *HelpText) Init() {
-//	help.inParams = [2]string{"configfile", "configPath"}
-//}
+//	func (help *HelpText) Init() {
+//		help.inParams = [2]string{"configfile", "configPath"}
+//	}
 func (help *HelpText) PrintLicense() {
 	fmt.Println(help.GetHelpText())
 }

src/Objects/Configuration.go …mysqloperatorcalculator/Configuration.gosrc/Objects/Configuration.go renamed to src/mysqloperatorcalculator/Configuration.go src/Objects/Configuration.go renamed to src/mysqloperatorcalculator/Configuration.go

@@ -1,4 +1,4 @@
-package Objects
+package mysqloperatorcalculator
 
 import (
 	"bytes"
@@ -21,6 +21,18 @@ const ErrorexecT = "There is an error while processing. See details: %s"
 // Structure definitions
 //********************************
 
+// MySQL version definition
+type Version struct {
+	Major int `json:"major"`
+	Minor int `json:"minor"`
+	Patch int `json:"patch"`
+}
+
+type MySQLVersions struct {
+	Min Version `json:"min"`
+	Max Version `json:"max"`
+}
+
 // ResponseMessage Message is the retruned message
 type ResponseMessage struct {
 	MType int    `json:"type"`
@@ -30,20 +42,22 @@ type ResponseMessage struct {
 
 // Configuration used to pass available configurations
 type Configuration struct {
-	DBType      []string    `json:"dbtype"`
-	Dimension   []Dimension `json:"dimension"`
-	LoadType    []LoadType  `json:"loadtype"`
-	Connections []int       `json:"connections"`
-	Output      []string    `json:"output"`
+	DBType        []string      `json:"dbtype"`
+	Dimension     []Dimension   `json:"dimension"`
+	LoadType      []LoadType    `json:"loadtype"`
+	Connections   []int         `json:"connections"`
+	Output        []string      `json:"output"`
+	Mysqlversions MySQLVersions `json:"mysqlversions"`
 }
 
 // ConfigurationRequest used to store the incoming request
 type ConfigurationRequest struct {
-	DBType      string    `json:"dbtype"`
-	Dimension   Dimension `json:"dimension"`
-	LoadType    LoadType  `json:"loadtype"`
-	Connections int       `json:"connections"`
-	Output      string    `json:"output"`
+	DBType       string    `json:"dbtype"`
+	Dimension    Dimension `json:"dimension"`
+	LoadType     LoadType  `json:"loadtype"`
+	Connections  int       `json:"connections"`
+	Output       string    `json:"output"`
+	Mysqlversion Version   `json:"mysqlversion"`
 }
 
 // Dimension used to represent the POD dimension
@@ -160,6 +174,9 @@ func (conf *Configuration) Init() {
 	}
 
 	conf.Connections = []int{50, 100, 200, 500, 1000, 2000}
+
+	//MySQL SUpported version (testing is with hardcoded then we need to query check.percona.com
+	conf.getMySQLVersion()
 }
 
 func (family *Family) Init(DBTypeRequest string) map[string]Family {
@@ -406,3 +423,9 @@ func InBetween(i, min, max int) bool {
 		return false
 	}
 }
+
+// TODO	***MySQL Supported version (testing is with hardcoded then we need to query check.percona.com ***
+func (conf *Configuration) getMySQLVersion() {
+	conf.Mysqlversions.Max = Version{8, 1, 0}
+	conf.Mysqlversions.Min = Version{8, 0, 32}
+}