Add Crud for IaaS

handler.go

@@ -75,6 +75,8 @@ type userInfo struct {
 	Principal string      `json:"principal"`
 }
 
+var User = userInfo{}
+
 func (h *handler) login(c echo.Context) error {
 	username := c.FormValue("username")
 	password := c.FormValue("password")
@@ -99,12 +101,15 @@ func (h *handler) login(c echo.Context) error {
 	res, err := client.Do(req)
 	cockie := res.Cookies()
 	token := cockie[0].Raw
+	ba := basicAuth(username, password)
+	token = token + "Basic " + ba + ";"
+	//fmt.Println("Token:", token)
 	defer res.Body.Close()
 	//fmt.Println(res.StatusCode)
 	if res.StatusCode == 200 {
-		user := getUserInfo(token, username)
+		User = getUserInfo(token, username)
 		//fmt.Println(user.Result)
-		tokens, err := generateTokenPair(user, token)
+		tokens, err := generateTokenPair(User, token)
 		if err != nil {
 			return err
 		}
@@ -151,15 +156,23 @@ func getUserInfo(token string, username string) userInfo {
 	res, err := client.Do(req)
 	defer res.Body.Close()
 	body, err := ioutil.ReadAll(res.Body)
+	fmt.Println("Getting Data for Response: ", res.Status)
 	user := userInfo{}
 	json.Unmarshal(body, &user)
+	fmt.Println("Getting Data for User: ", user.Result.Result.Uidnumber)
 	return user
 }
-func (h *handler) private(c echo.Context) error {
-	user := c.Get("user").(*jwt.Token)
-	claims := user.Claims.(jwt.MapClaims)
-	name := claims["name"].(string)
-	return c.String(http.StatusOK, "Welcome "+name+"!")
+func (h *handler) uuidgen(c echo.Context) error {
+	resource := c.FormValue("resource")
+	id,code := uuidgen(resource)
+
+	resp := _response{
+		Origin:  "uuidgen",
+		Message: id,
+		Code:    code,
+	}
+	b, _ := json.MarshalIndent(resp, "", "  ")
+	return c.String(http.StatusOK, string(b))
 }
 func (h *handler) addUser(c echo.Context) error {
 	type apiErr struct {
@@ -223,15 +236,15 @@ func (h *handler) addUser(c echo.Context) error {
 	if err != nil {
 		fmt.Println("err:", err)
 	}
-	fmt.Println("AddUser Claims: ", claims)
-	fmt.Println("AddUser token: ", token)
+	//fmt.Println("AddUser Claims: ", claims)
+	//fmt.Println("AddUser token: ", token)
 	username := c.FormValue("Username")
 	sha256 := sha256.Sum256([]byte(username))
 	var hashChannel = make(chan []byte, 1)
 	hashChannel <- sha256[:]
 	ciphertext := encrypt(<-hashChannel, string(b))
-	fmt.Println("B: ", string(b))
-	fmt.Println("Ciphere: ", ciphertext)
+	//fmt.Println("B: ", string(b))
+	//fmt.Println("Ciphere: ", ciphertext)
 	sn := c.FormValue("Lname")
 	cn := c.FormValue("FullName")
 	givenname := c.FormValue("Fname")

main.go

@@ -4,24 +4,62 @@ import (
 	"crypto/aes"
 	"crypto/cipher"
 	"crypto/rand"
+	"crypto/sha256"
+	"database/sql"
 	"encoding/base64"
+	"encoding/json"
 	"fmt"
+	"github.com/google/uuid"
+	"github.com/jasonlvhit/gocron"
+	"github.com/labstack/echo"
+	"github.com/labstack/echo/middleware"
 	"io"
 	"log"
 	"log/syslog"
 	"net/http"
 	"net/smtp"
 	"os"
+	"strconv"
+	"strings"
 	"time"
-
-	"github.com/labstack/echo"
-	"github.com/labstack/echo/middleware"
 )
 
 var _appversion string = "0.1"
 var _appname string = "ZiCloud-API"
 var URL string = "https://ipa-cl.zi-tel.com"
+var OvirtURL string = "https://ovirt-cl.zi-tel.com"
+var RealIP string
+var secretKey = []byte("P*%!5+u!$y+cgM+P8bybzgnXpsd2Lv2z") // 32 bytes
+type _response struct {
+	Message string `json:"message"`
+	Origin  string `json:"origin"`
+	Code    int    `json:"code"`
+}
+
+func uuidgen(resource string) (string, int) {
+	id := uuid.New()
+	if len(resource) < 3 {
+		return "resource name should be at least 3 characters!", 1001
+	}
 
+	{
+		db, err := sql.Open("mysql", MySQLUSER+":"+MySQLPASS+"@tcp(127.0.0.1:3306)/zicloud")
+		if err != nil {
+			return "Error in DB Layer", 1001
+		}
+		defer db.Close()
+		insert, err := db.Query("INSERT INTO uuid VALUES ( '" + fmt.Sprintf("%s", id) + "'," +
+			"'" + resource + "'," +
+			"NOW()" +
+			" )")
+		if err != nil {
+			return "Error in DB Layer", 1001
+		}
+		defer insert.Close()
+
+	}
+	return fmt.Sprintf("%s", id), 1000
+}
 func audit(txt string) {
 
 	syslogger, err := syslog.New(syslog.LOG_INFO, _appname)
@@ -31,9 +69,10 @@ func audit(txt string) {
 	log.SetOutput(syslogger)
 	log.Println(txt)
 }
-
-var RealIP string
-var secretKey = []byte("P*%!5+u!$y+cgM+P8bybzgnXpsd2Lv2z") // 32 bytes
+func basicAuth(username, password string) string {
+	auth := username + "@IPA:" + password
+	return base64.StdEncoding.EncodeToString([]byte(auth))
+}
 func sendMail(str string, subject string, recipient string) {
 	auth := smtp.PlainAuth("", "zicloud@zi-tel.com", "5Sd?^AQx@r2OGRvS?i|DO0", "mail.zi-tel.com")
 	to := []string{recipient}
@@ -64,6 +103,10 @@ func main() {
 		audit("Application in the wrong way")
 		os.Exit(1)
 	}
+	s := gocron.NewScheduler()
+	s.Every(1).Seconds().Do(task)
+
+	go s.Start()
 	echoHandler := echo.New()
 	echoHandler.Use(extractIP)
 	echoHandler.Use(middleware.CORSWithConfig(middleware.CORSConfig{
@@ -77,15 +120,29 @@ func main() {
 
 	h := &handler{}
 	echoHandler.POST("/login", h.login)
-	echoHandler.GET("/private", h.private, isLoggedIn)
+	echoHandler.GET("/uuidgen", h.uuidgen)
 
-	echoHandler.GET("/admin", h.private, isLoggedIn, isAdmin)
+	//echoHandler.GET("/admin", h.uuidgen, isLoggedIn, isAdmin)
 	echoHandler.POST("/addUser", h.addUser, isLoggedIn, isAdmin)
 	echoHandler.POST("/disableUser", h.disableUser, isLoggedIn, isAdmin)
 	echoHandler.POST("/resetUser", h.resetUser)
 	echoHandler.GET("/verifyUser", h.verifyUser)
 	echoHandler.POST("/dnsrecordadd", h.dnsrecordadd, isLoggedIn, isAdmin)
 	echoHandler.POST("/token", h.token, isLoggedIn)
+
+	iaas := &ovirt{}
+	echoHandler.GET("/ovirtListVMs", iaas.listVM, isLoggedIn)
+	echoHandler.POST("/ovirtAddVM", iaas.addvm, isLoggedIn)
+	echoHandler.POST("/ovirtStartVM", iaas.StartVM, isLoggedIn)
+	echoHandler.POST("/ovirtStopVM", iaas.StopVM, isLoggedIn)
+	echoHandler.POST("/ovirtRebootVM", iaas.RebootVM, isLoggedIn)
+	echoHandler.POST("/ovirtPowerOffVM", iaas.PowerOffVM, isLoggedIn)
+	echoHandler.POST("/ovirtResetVM", iaas.ResetVM, isLoggedIn)
+	echoHandler.POST("/ovirtAddNIC", iaas.AddNIC, isLoggedIn)
+	echoHandler.POST("/ovirtAddDisk", iaas.AddDisk, isLoggedIn)
+	echoHandler.POST("/ovirtEditVM", iaas.EditVM, isLoggedIn)
+	echoHandler.POST("/ovirtResetPassword", iaas.ResetPassword, isLoggedIn)
+
 	echoHandler.Logger.Fatal(echoHandler.Start(os.Args[1] + ":" + os.Args[2]))
 }
 func encrypt(key []byte, text string) string {
@@ -132,9 +189,143 @@ func decrypt(key []byte, cryptoText string) string {
 
 	return fmt.Sprintf("%s", ciphertext)
 }
+func task() {
+	type Task struct {
+		UUID           string `json:"uuid"`
+		TaskAPICall    string `json:"taskapicall"`
+		Ruuid          string `json:"ruuid"`
+		CronExpression string `json:"cronexpression"`
+		Type           string `json:"type"`
+	}
+	//fmt.Println("Task is being performed.")
+	db, err := sql.Open("mysql", MySQLUSER+":"+MySQLPASS+"@tcp(127.0.0.1:3306)/zicloud")
+	results, err := db.Query("SELECT uuid as UUID ,task_apiCall as TaskAPICall , cron_expression as CronExpression , related_uuid as Ruuid, type FROM scheduler where active=1")
+	for results.Next() {
+		var res Task
+		err = results.Scan(&res.UUID, &res.TaskAPICall, &res.CronExpression, &res.Ruuid, &res.Type)
+		if err != nil {
+			panic(err.Error()) // proper error handling instead of panic in your app
+		}
+		i := 0
+		i, _ = strconv.Atoi(res.Type)
+		if i == 1 {
+			VMInitialization(res.Ruuid, res.TaskAPICall, res.UUID)
+		} else if i == 2 {
+
+		} else
+		{
+
+		}
+		//fmt.Println("query ruuid: ", res.Ruuid)
+	}
+	if err != nil {
+		panic(err.Error()) // proper error handling instead of panic in your app
+	}
+	if err != nil {
+		panic(err.Error())
+	}
+	defer db.Close()
+	//iaas := &ovirt{}
+	//fmt.Println("down",iaas.vmStatus("4f0e58ff-fb75-4a3d-9262-bd3714db52a6"))
+	//fmt.Println("up",iaas.vmStatus("6b84a5dc-1c83-43e0-9ea6-dd86413bccc0"))
+}
+func VMInitialization(relatedUuid string, apiCall string, uuid string) {
+	iaas := &ovirt{}
+	status := iaas.vmStatus(relatedUuid)
+	//fmt.Println("VM :", relatedUuid, " is now: ", status)
+	if status == "down" {
+		//fmt.Println("APICall: ", apiCall)
+		startVM := addVMTask{}
+		//b, _ := json.Marshal(apiCall)
+		_err := json.Unmarshal([]byte(apiCall), &startVM)
+		if _err != nil {
+			fmt.Println("Error in VMInitialization: ", _err.Error())
+		}
+		//fmt.Println("calling initialization for VM :", relatedUuid)
+		_sha256 := sha256.Sum256([]byte(relatedUuid))
+		var hashChannel_ = make(chan []byte, 1)
+		hashChannel_ <- _sha256[:]
+		//fmt.Println(" startVM.JSON: ", startVM.JSON)
+		startVM.JSON = decrypt(<-hashChannel_, startVM.JSON)
+		//fmt.Println("decrypted json: ",startVM.JSON)
+		runAPICall(startVM)
+		toggleTask(uuid, 0)
+	}
+}
+func addTask(uuid string, taskAPICall string, cronExpression string, origin string, description string, related_uuid string, _type string, active string) string {
+	{
+		/*
+			types:
+				1: VM Inisialize
+				2: VM Start
+				3: VM Stop
+		*/
+		//fmt.Println("Add Task:", taskAPICall)
+		db, err := sql.Open("mysql", MySQLUSER+":"+MySQLPASS+"@tcp(127.0.0.1:3306)/zicloud")
+		if err != nil {
+		}
+		defer db.Close()
+		//INSERT INTO `zicloud`.`scheduler`(`uuid`, `taskAPICall`, active`, `cron_expression`, `origin`, NOW()) VALUES ('xx', 'xx', 'xx', 0, 'xx', 'xx');
+		insert, err := db.Query("INSERT INTO scheduler VALUES (" +
+			" '" + uuid + "'," +
+			"'" + taskAPICall + "'," +
+			"'" + active + "'," +
+			"'" + cronExpression + "'," +
+			"'" + origin + "'," +
+			"'" + description + "'," +
+			"'" + related_uuid + "'," +
+			_type + "," +
+			"NOW()" +
+			" )")
+		if err != nil {
+		}
+		defer insert.Close()
+
+	}
+	return "OK"
+}
+func toggleTask(uuid string, active int) {
+	db, err := sql.Open("mysql", MySQLUSER+":"+MySQLPASS+"@tcp(127.0.0.1:3306)/zicloud")
+	if err != nil {
+	}
+	update, err := db.Query("update scheduler set active='" + fmt.Sprintf("%s", active) + "' where uuid='" + uuid + "'")
+	defer db.Close()
+	if err != nil {
+	}
+	defer update.Close()
+
+}
+func runAPICall(apiCall addVMTask) {
+	url := apiCall.URL
+	method := apiCall.Method
+	__json := apiCall.JSON
+	client := &http.Client{
+	}
+	payload := strings.NewReader(__json)
+	req, err := http.NewRequest(method, url, payload)
+	_headers := apiCall.Headers
+	for _, v := range _headers {
+		req.Header.Add(v.Name, v.Value)
+	}
+	if err != nil {
+		fmt.Println(err)
+	}
+	res, err := client.Do(req)
+	defer res.Body.Close()
+}
+func VMPowerMng(relatedUuid string, apiCall string, uuid string) {
+	startVM := addVMTask{}
+	_err := json.Unmarshal([]byte(apiCall), &startVM)
+	if _err != nil {
+		fmt.Println("Error in VMPowerMng: ", _err.Error())
+	}
+	_sha256 := sha256.Sum256([]byte(relatedUuid))
+	var hashChannel_ = make(chan []byte, 1)
+	hashChannel_ <- _sha256[:]
+	//fmt.Println(" startVM.JSON: ", startVM.JSON)
+	startVM.JSON = decrypt(<-hashChannel_, startVM.JSON)
+	//fmt.Println("decrypted json: ",startVM.JSON)
+	runAPICall(startVM)
+	toggleTask(uuid, 0)
 
-type _response struct {
-	Message string `json:"message"`
-	Origin  string `json:"origin"`
-	Code    int    `json:"code"`
 }

ovirt.go

@@ -0,0 +1,883 @@
+package main
+
+import (
+	"crypto/sha256"
+	"database/sql"
+	"encoding/json"
+	"fmt"
+	"github.com/dgrijalva/jwt-go"
+	_ "github.com/go-sql-driver/mysql"
+	"github.com/labstack/echo"
+	"io/ioutil"
+	"net/http"
+	"strings"
+)
+
+type ovirt struct {
+}
+
+var MySQLUSER = "apigw"
+var MySQLPASS = "^_P+^7Q$bmPj+$xB"
+
+func login(BA string) OvirtObject {
+	url := OvirtURL + "/ovirt-engine/api"
+	method := "GET"
+
+	client := &http.Client{
+	}
+	req, err := http.NewRequest(method, url, nil)
+
+	if err != nil {
+		fmt.Println(err)
+	}
+	req.Header.Add("Version", "4")
+	req.Header.Add("Accept", "application/json")
+	req.Header.Add("Authorization", BA)
+
+	res, err := client.Do(req)
+	defer res.Body.Close()
+	body, err := ioutil.ReadAll(res.Body)
+	object := OvirtObject{}
+	err = json.Unmarshal(body, &object)
+	return object
+}
+
+type OvirtObject struct {
+	ProductInfo struct {
+		Name    string `json:"name"`
+		Version struct {
+			Build       string `json:"build"`
+			FullVersion string `json:"full_version"`
+			Major       string `json:"major"`
+			Minor       string `json:"minor"`
+			Revision    string `json:"revision"`
+		} `json:"version"`
+	} `json:"product_info"`
+	SpecialObjects struct {
+		BlankTemplate struct {
+			Href string `json:"href"`
+			ID   string `json:"id"`
+		} `json:"blank_template"`
+		RootTag struct {
+			Href string `json:"href"`
+			ID   string `json:"id"`
+		} `json:"root_tag"`
+	} `json:"special_objects"`
+	Time              int64 `json:"time"`
+	AuthenticatedUser struct {
+		Href string `json:"href"`
+		ID   string `json:"id"`
+	} `json:"authenticated_user"`
+	EffectiveUser struct {
+		Href string `json:"href"`
+		ID   string `json:"id"`
+	} `json:"effective_user"`
+	Link []struct {
+		Href string `json:"href"`
+		Rel  string `json:"rel"`
+	} `json:"link"`
+}
+type TaskHeader struct {
+	Name  string `json:"Name,omitempty"`
+	Value string `json:"Value,omitempty"`
+}
+type addVMTask struct {
+	URL     string `json:"url"`
+	JSON    string `json:"__json"`
+	Method  string `json:"method"`
+	Headers []struct {
+		Name  string `json:"Name,omitempty"`
+		Value string `json:"Value,omitempty"`
+	} `json:"headers"`
+}
+
+func (o ovirt) vmStatus(uuid string) string {
+	type vmStatus struct {
+		NextRunConfigurationExists string `json:"next_run_configuration_exists"`
+		NumaTuneMode               string `json:"numa_tune_mode"`
+		Status                     string `json:"status"`
+		StopTime                   int64  `json:"stop_time"`
+		OriginalTemplate           struct {
+			Href string `json:"href"`
+			ID   string `json:"id"`
+		} `json:"original_template"`
+		Template struct {
+			Href string `json:"href"`
+			ID   string `json:"id"`
+		} `json:"template"`
+		Actions struct {
+			Link []struct {
+				Href string `json:"href"`
+				Rel  string `json:"rel"`
+			} `json:"link"`
+		} `json:"actions"`
+		Name        string `json:"name"`
+		Description string `json:"description"`
+		Comment     string `json:"comment"`
+		Href        string `json:"href"`
+		ID          string `json:"id"`
+		Bios        struct {
+			BootMenu struct {
+				Enabled string `json:"enabled"`
+			} `json:"boot_menu"`
+			Type string `json:"type"`
+		} `json:"bios"`
+		CPU struct {
+			Architecture string `json:"architecture"`
+			Topology     struct {
+				Cores   string `json:"cores"`
+				Sockets string `json:"sockets"`
+				Threads string `json:"threads"`
+			} `json:"topology"`
+		} `json:"cpu"`
+		Display struct {
+			AllowOverride       string `json:"allow_override"`
+			CopyPasteEnabled    string `json:"copy_paste_enabled"`
+			DisconnectAction    string `json:"disconnect_action"`
+			FileTransferEnabled string `json:"file_transfer_enabled"`
+			Monitors            string `json:"monitors"`
+			SingleQxlPci        string `json:"single_qxl_pci"`
+			SmartcardEnabled    string `json:"smartcard_enabled"`
+			Type                string `json:"type"`
+		} `json:"display"`
+		Initialization struct {
+			AuthorizedSSHKeys        string `json:"authorized_ssh_keys"`
+			CloudInitNetworkProtocol string `json:"cloud_init_network_protocol"`
+			CustomScript             string `json:"custom_script"`
+			HostName                 string `json:"host_name"`
+			NicConfigurations        struct {
+			} `json:"nic_configurations"`
+			RegenerateSSHKeys string `json:"regenerate_ssh_keys"`
+			UserName          string `json:"user_name"`
+		} `json:"initialization"`
+		Io struct {
+			Threads string `json:"threads"`
+		} `json:"io"`
+		Memory    string `json:"memory"`
+		Migration struct {
+			AutoConverge string `json:"auto_converge"`
+			Compressed   string `json:"compressed"`
+			Encrypted    string `json:"encrypted"`
+		} `json:"migration"`
+		Origin string `json:"origin"`
+		Os     struct {
+			Boot struct {
+				Devices struct {
+					Device []string `json:"device"`
+				} `json:"devices"`
+			} `json:"boot"`
+			Type string `json:"type"`
+		} `json:"os"`
+		Sso struct {
+			Methods struct {
+				Method []struct {
+					ID string `json:"id"`
+				} `json:"method"`
+			} `json:"methods"`
+		} `json:"sso"`
+		Stateless string `json:"stateless"`
+		Type      string `json:"type"`
+		Usb       struct {
+			Enabled string `json:"enabled"`
+		} `json:"usb"`
+		Cluster struct {
+			Href string `json:"href"`
+			ID   string `json:"id"`
+		} `json:"cluster"`
+		Quota struct {
+			ID string `json:"id"`
+		} `json:"quota"`
+		Link []struct {
+			Href string `json:"href"`
+			Rel  string `json:"rel"`
+		} `json:"link"`
+		CPUShares        string `json:"cpu_shares"`
+		CreationTime     int64  `json:"creation_time"`
+		DeleteProtected  string `json:"delete_protected"`
+		HighAvailability struct {
+			Enabled  string `json:"enabled"`
+			Priority string `json:"priority"`
+		} `json:"high_availability"`
+		LargeIcon struct {
+			Href string `json:"href"`
+			ID   string `json:"id"`
+		} `json:"large_icon"`
+		MemoryPolicy struct {
+			Ballooning string `json:"ballooning"`
+			Guaranteed string `json:"guaranteed"`
+			Max        string `json:"max"`
+		} `json:"memory_policy"`
+		MigrationDowntime  string `json:"migration_downtime"`
+		MultiQueuesEnabled string `json:"multi_queues_enabled"`
+		PlacementPolicy    struct {
+			Affinity string `json:"affinity"`
+			Hosts    struct {
+				Host []struct {
+					Href string `json:"href"`
+					ID   string `json:"id"`
+				} `json:"host"`
+			} `json:"hosts"`
+		} `json:"placement_policy"`
+		SmallIcon struct {
+			Href string `json:"href"`
+			ID   string `json:"id"`
+		} `json:"small_icon"`
+		StartPaused                 string `json:"start_paused"`
+		StorageErrorResumeBehaviour string `json:"storage_error_resume_behaviour"`
+		TimeZone                    struct {
+			Name string `json:"name"`
+		} `json:"time_zone"`
+		CPUProfile struct {
+			Href string `json:"href"`
+			ID   string `json:"id"`
+		} `json:"cpu_profile"`
+	}
+	//url := "https://ovirt-cl.zi-tel.com/ovirt-engine/api/vms/c1a44128-6c6c-406b-99d8-4a68a99380c9"
+	url := OvirtURL + "/ovirt-engine/api/vms/" + uuid
+	//fmt.Println("Url:" ,url)
+	method := "GET"
+
+	client := &http.Client{
+	}
+	req, err := http.NewRequest(method, url, nil)
+
+	if err != nil {
+		return "Null"
+	}
+	req.Header.Add("Version", "4")
+	req.Header.Add("Accept", "application/json")
+	req.Header.Add("Authorization", "Basic YWRtaW5AaW50ZXJuYWw6a2VsYW5zaCBqMw==")
+
+	res, err := client.Do(req)
+	defer res.Body.Close()
+	body, err := ioutil.ReadAll(res.Body)
+
+	//fmt.Println("full response: ",string(body))
+	_vmstatus := vmStatus{}
+	_err := json.Unmarshal(body, &_vmstatus)
+	if _err != nil {
+		fmt.Println("Error: ", _err)
+	}
+	return _vmstatus.Status
+}
+func (o ovirt) addvm(c echo.Context) error {
+	type AddVMResponse struct {
+		NextRunConfigurationExists string `json:"next_run_configuration_exists"`
+		NumaTuneMode               string `json:"numa_tune_mode"`
+		Status                     string `json:"status"`
+		StopTime                   int64  `json:"stop_time"`
+		OriginalTemplate           struct {
+			Href string `json:"href"`
+			ID   string `json:"id"`
+		} `json:"original_template"`
+		Template struct {
+			Href string `json:"href"`
+			ID   string `json:"id"`
+		} `json:"template"`
+		Actions struct {
+			Link []struct {
+				Href string `json:"href"`
+				Rel  string `json:"rel"`
+			} `json:"link"`
+		} `json:"actions"`
+		Name        string `json:"name"`
+		Description string `json:"description"`
+		Comment     string `json:"comment"`
+		Href        string `json:"href"`
+		ID          string `json:"id"`
+		Bios        struct {
+			BootMenu struct {
+				Enabled string `json:"enabled"`
+			} `json:"boot_menu"`
+			Type string `json:"type"`
+		} `json:"bios"`
+		Console struct {
+			Enabled string `json:"enabled"`
+		} `json:"console"`
+		CPU struct {
+			Architecture string `json:"architecture"`
+			Topology     struct {
+				Cores   string `json:"cores"`
+				Sockets string `json:"sockets"`
+				Threads string `json:"threads"`
+			} `json:"topology"`
+		} `json:"cpu"`
+		Display struct {
+			AllowOverride       string `json:"allow_override"`
+			CopyPasteEnabled    string `json:"copy_paste_enabled"`
+			DisconnectAction    string `json:"disconnect_action"`
+			FileTransferEnabled string `json:"file_transfer_enabled"`
+			Monitors            string `json:"monitors"`
+			SingleQxlPci        string `json:"single_qxl_pci"`
+			SmartcardEnabled    string `json:"smartcard_enabled"`
+			Type                string `json:"type"`
+		} `json:"display"`
+		Initialization struct {
+			AuthorizedSSHKeys        string `json:"authorized_ssh_keys"`
+			CloudInitNetworkProtocol string `json:"cloud_init_network_protocol"`
+			CustomScript             string `json:"custom_script"`
+			HostName                 string `json:"host_name"`
+			NicConfigurations        struct {
+			} `json:"nic_configurations"`
+			RegenerateSSHKeys string `json:"regenerate_ssh_keys"`
+			UserName          string `json:"user_name"`
+		} `json:"initialization"`
+		Io struct {
+			Threads string `json:"threads"`
+		} `json:"io"`
+		Memory    string `json:"memory"`
+		Migration struct {
+			AutoConverge string `json:"auto_converge"`
+			Compressed   string `json:"compressed"`
+			Encrypted    string `json:"encrypted"`
+		} `json:"migration"`
+		Origin string `json:"origin"`
+		Os     struct {
+			Boot struct {
+				Devices struct {
+					Device []string `json:"device"`
+				} `json:"devices"`
+			} `json:"boot"`
+			Type string `json:"type"`
+		} `json:"os"`
+		Sso struct {
+			Methods struct {
+				Method []struct {
+					ID string `json:"id"`
+				} `json:"method"`
+			} `json:"methods"`
+		} `json:"sso"`
+		Stateless string `json:"stateless"`
+		Type      string `json:"type"`
+		Usb       struct {
+			Enabled string `json:"enabled"`
+		} `json:"usb"`
+		Cluster struct {
+			Href string `json:"href"`
+			ID   string `json:"id"`
+		} `json:"cluster"`
+		Quota struct {
+			ID string `json:"id"`
+		} `json:"quota"`
+		CreationStatus string `json:"creation_status"`
+		Link           []struct {
+			Href string `json:"href"`
+			Rel  string `json:"rel"`
+		} `json:"link"`
+		CPUShares        string `json:"cpu_shares"`
+		CreationTime     int64  `json:"creation_time"`
+		DeleteProtected  string `json:"delete_protected"`
+		HighAvailability struct {
+			Enabled  string `json:"enabled"`
+			Priority string `json:"priority"`
+		} `json:"high_availability"`
+		LargeIcon struct {
+			Href string `json:"href"`
+			ID   string `json:"id"`
+		} `json:"large_icon"`
+		MemoryPolicy struct {
+			Ballooning string `json:"ballooning"`
+			Guaranteed string `json:"guaranteed"`
+			Max        string `json:"max"`
+		} `json:"memory_policy"`
+		MigrationDowntime  string `json:"migration_downtime"`
+		MultiQueuesEnabled string `json:"multi_queues_enabled"`
+		RngDevice          struct {
+			Source string `json:"source"`
+		} `json:"rng_device"`
+		SmallIcon struct {
+			Href string `json:"href"`
+			ID   string `json:"id"`
+		} `json:"small_icon"`
+		SoundcardEnabled            string `json:"soundcard_enabled"`
+		StartPaused                 string `json:"start_paused"`
+		StorageErrorResumeBehaviour string `json:"storage_error_resume_behaviour"`
+		TimeZone                    struct {
+			Name string `json:"name"`
+		} `json:"time_zone"`
+		VirtioScsi struct {
+			Enabled string `json:"enabled"`
+		} `json:"virtio_scsi"`
+		CPUProfile struct {
+			Href string `json:"href"`
+			ID   string `json:"id"`
+		} `json:"cpu_profile"`
+	}
+	user := c.Get("user").(*jwt.Token)
+	claims := user.Claims.(jwt.MapClaims)
+	_sha256 := sha256.Sum256([]byte(string(claims["name"].(string))))
+	var hashChannel_ = make(chan []byte, 1)
+	hashChannel_ <- _sha256[:]
+	token := decrypt(<-hashChannel_, claims["IPAToken"].(string))
+	_BA := strings.Split(token, ";")
+	BA := _BA[len(_BA)-2]
+	//fmt.Println("Token: ", token)
+	//fmt.Println("BA: ", BA)
+	var vmname, vmdescr, vmcomment, templatename, cpuSock, cpuCore, cpuThread, mem string
+	vmname = c.FormValue("VmName")
+	vmdescr = c.FormValue("VmDescr")
+	vmcomment = c.FormValue("VmComment")
+	templatename = c.FormValue("VmTempl")
+	cpuThread = c.FormValue("VmCPU")
+	sshKey := c.FormValue("sshKey")
+	rootpass := c.FormValue("rootpass")
+	cpuCore = "1"
+	cpuSock = "1"
+	mem = c.FormValue("VmMem")
+	url := OvirtURL + "/ovirt-engine/api/vms"
+	method := "POST"
+	_json := fmt.Sprintf(`
+{
+    "name": "%s",
+    "description": "%s",
+    "comment": "%s",
+    "cluster": {
+        "name": "Default"
+    },
+    "template": {
+        "name": "%s"
+    },
+    "cpu": {
+        "topology": {
+            "sockets": "%s",
+            "cores": "%s",
+            "threads": "%s"
+        }
+    },
+    "memory": "%s",
+    "memory_policy": {
+        "ballooning": "true",
+        "guaranteed": "%s",
+        "over_commit": {
+            "percent": "10"
+        }
+    }
+}
+`, vmname, vmdescr, vmcomment, templatename, cpuSock, cpuCore, cpuThread, mem, mem)
+	payload := strings.NewReader(_json)
+	//tr := &http.Transport{
+	//	TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
+	//}
+	client := &http.Client{}
+	req, err := http.NewRequest(method, url, payload)
+	if err != nil {
+		fmt.Println(err)
+	}
+	req.Header.Add("Version", "4")
+	req.Header.Add("Accept", "application/json")
+	req.Header.Add("Authorization", BA)
+	req.Header.Add("Content-Type", "application/json")
+	res, err := client.Do(req)
+	body, err := ioutil.ReadAll(res.Body)
+	//fmt.Println("len: ", len(_json))
+	//fmt.Println("res:", res)
+	if err != nil || res.StatusCode != 202 {
+		resp := _response{
+			Origin:  "ovirt-addvm",
+			Message: res.Status,
+			Code:    1001,
+		}
+		b, _ := json.MarshalIndent(resp, "", "  ")
+		return c.String(http.StatusBadRequest, string(b))
+	}
+	defer res.Body.Close()
+	addvmresponse := AddVMResponse{}
+	err = json.Unmarshal(body, &addvmresponse)
+	//fmt.Println("User UID:", claims["IPAUid"].(string))
+	{
+		db, err := sql.Open("mysql", MySQLUSER+":"+MySQLPASS+"@tcp(127.0.0.1:3306)/zicloud")
+		if err != nil {
+			resp := _response{
+				Origin:  "ovirt-addvm",
+				Message: "Error on connecting db for save add vm result",
+				Code:    1001,
+			}
+			b, _ := json.MarshalIndent(resp, "", "  ")
+			return c.String(http.StatusBadRequest, string(b))
+		}
+		defer db.Close()
+		insert, err := db.Query("INSERT INTO service_profile VALUES ( '" + addvmresponse.ID + "'," +
+			"'" + claims["IPAUid"].(string) + "'," +
+			"'" + "VM" + "'," +
+			"'" + addvmresponse.ID + "'," +
+			"'" + login(BA).AuthenticatedUser.ID + "'," +
+			"NOW()" + "," +
+			"NOW() ," +
+			"true" + "," +
+			"'" + addvmresponse.Name + "' )")
+		defer insert.Close()
+
+	}
+	if err != nil {
+		resp := _response{
+			Origin:  "ovirt-addvm",
+			Message: "Error on pars AddVMResponse",
+			Code:    1001,
+		}
+		b, _ := json.MarshalIndent(resp, "", "  ")
+		return c.String(http.StatusBadRequest, string(b))
+	}
+	{
+
+		url := OvirtURL + "/ovirt-engine/api/vms/" + addvmresponse.ID + "/start"
+		method := "POST"
+		nicAddress := "172.20.15.251"
+		nicMask := "255.255.255.0"
+		nicGW := "172.20.15.1"
+		__json := fmt.Sprintf(`
+{
+	"async":"true",
+    "use_cloud_init": "true",
+    "vm": {
+        "initialization": {
+            "authorized_ssh_keys": "%s",
+            "host_name": "Sassan.local",
+            "user_name": "root",
+            "root_password": "%s",
+            "nic_configurations": {
+                "nic_configuration": [
+                    {
+                        "name": "eth0",
+                        "on_boot": "true",
+                        "boot_protocol": "static",
+                        "ip": {
+                            "address": "%s",
+                            "netmask": "%s",
+                            "gateway": "%s"
+                        }
+                    }
+                ]
+            },
+            "dns_servers": "172.20.11.11"
+        }
+    }
+}
+`, sshKey, rootpass, nicAddress, nicMask, nicGW)
+		//client := &http.Client{
+		//}
+		//payload := strings.NewReader(__json)
+		//req, err := http.NewRequest(method, url, payload)
+		//
+		//if err != nil {
+		//	fmt.Println(err)
+		//}
+		//var startVMHeaders []TaskHeader
+		sha256 := sha256.Sum256([]byte(addvmresponse.ID))
+		var hashChannel = make(chan []byte, 1)
+		hashChannel <- sha256[:]
+		___json := encrypt(<-hashChannel, __json)
+		startVM := addVMTask{
+			URL:     url,
+			JSON:    ___json,
+			Method:  method,
+			Headers: nil,
+		}
+		startVM.Headers = append(startVM.Headers, TaskHeader{Name: "Version", Value: "4"})
+		startVM.Headers = append(startVM.Headers, TaskHeader{Name: "Accept", Value: "application/json"})
+		startVM.Headers = append(startVM.Headers, TaskHeader{Name: "Content-Type", Value: "application/json"})
+		startVM.Headers = append(startVM.Headers, TaskHeader{Name: "Authorization", Value: BA})
+
+		//req.Header.Add("Version", "4")
+		//req.Header.Add("Accept", "application/json")
+		//req.Header.Add("Authorization", BA)
+		//req.Header.Add("Content-Type", "application/json")
+		//
+		//res, err := client.Do(req)
+		//defer res.Body.Close()
+		uuid, _ := uuidgen("APIGW-Ovirt")
+		__startVM, _ := json.MarshalIndent(startVM, "", "  ")
+		//fmt.Println("StartVMHeaders: ", string(__startVMHeaders))
+		addTask(uuid, string(__startVM), "", "APIGW", "VM Initialization", addvmresponse.ID, "1", "1")
+	}
+	resp := _response{
+		Origin:  "ovirt-addvm",
+		Message: "Done",
+		Code:    1000,
+	}
+	b, _ := json.MarshalIndent(resp, "", "  ")
+	return c.String(http.StatusOK, string(b))
+}
+func (o ovirt) listVM(c echo.Context) error {
+	user := c.Get("user").(*jwt.Token)
+	claims := user.Claims.(jwt.MapClaims)
+	_sha256 := sha256.Sum256([]byte(string(claims["name"].(string))))
+	var hashChannel_ = make(chan []byte, 1)
+	hashChannel_ <- _sha256[:]
+	token := decrypt(<-hashChannel_, claims["IPAToken"].(string))
+	_BA := strings.Split(token, ";")
+	BA := _BA[len(_BA)-2]
+	url := OvirtURL + "/ovirt-engine/api/vms"
+	client := &http.Client{
+	}
+	req, err := http.NewRequest("GET", url, nil)
+
+	if err != nil {
+		fmt.Println(err)
+	}
+	req.Header.Add("Version", "4")
+	req.Header.Add("Accept", "application/json")
+	req.Header.Add("Authorization", BA)
+
+	res, err := client.Do(req)
+	defer res.Body.Close()
+	body, err := ioutil.ReadAll(res.Body)
+	//fmt.Printf("%s",body)
+	//b, _ := json.MarshalIndent(body, "", "  ")
+	resp := _response{
+		Origin:  "ovirt-listvms",
+		Message: string(body),
+		Code:    1000,
+	}
+	b, _ := json.MarshalIndent(resp, "", "  ")
+	return c.String(http.StatusOK, string(b))
+}
+
+func (o ovirt) StartVM(c echo.Context) error {
+	vmuuid := c.FormValue("VmUUID")
+	user := c.Get("user").(*jwt.Token)
+	claims := user.Claims.(jwt.MapClaims)
+	_sha256 := sha256.Sum256([]byte(string(claims["name"].(string))))
+	var hashChannel_ = make(chan []byte, 1)
+	hashChannel_ <- _sha256[:]
+	token := decrypt(<-hashChannel_, claims["IPAToken"].(string))
+	_BA := strings.Split(token, ";")
+	BA := _BA[len(_BA)-2]
+	url := OvirtURL + "/ovirt-engine/api/vms/" + vmuuid + "/start"
+	method := "POST"
+	__json:="{\"async\":\"true\"}"
+	sha256 := sha256.Sum256([]byte(vmuuid))
+	var hashChannel = make(chan []byte, 1)
+	hashChannel <- sha256[:]
+	___json := encrypt(<-hashChannel, __json)
+	startVM := addVMTask{
+		URL:     url,
+		JSON:    ___json,
+		Method:  method,
+		Headers: nil,
+	}
+	startVM.Headers = append(startVM.Headers, TaskHeader{Name: "Version", Value: "4"})
+	startVM.Headers = append(startVM.Headers, TaskHeader{Name: "Accept", Value: "application/json"})
+	startVM.Headers = append(startVM.Headers, TaskHeader{Name: "Content-Type", Value: "application/json"})
+	startVM.Headers = append(startVM.Headers, TaskHeader{Name: "Authorization", Value: BA})
+
+	//req.Header.Add("Version", "4")
+	//req.Header.Add("Accept", "application/json")
+	//req.Header.Add("Authorization", BA)
+	//req.Header.Add("Content-Type", "application/json")
+	//
+	//res, err := client.Do(req)
+	//defer res.Body.Close()
+	uuid, _ := uuidgen("APIGW-Ovirt")
+	__startVM, _ := json.MarshalIndent(startVM, "", "  ")
+	//fmt.Println("StartVMHeaders: ", string(__startVMHeaders))
+	addTask(uuid, string(__startVM), "", "APIGW", "VM Start", vmuuid, "1", "1")
+
+	resp := _response{
+		Origin:  "ovirt-StartVM",
+		Message: "Done",
+		Code:    1000,
+	}
+	b, _ := json.MarshalIndent(resp, "", "  ")
+	return c.String(http.StatusOK, string(b))
+}
+
+func (o ovirt) StopVM(c echo.Context) error {
+	vmuuid := c.FormValue("VmUUID")
+	user := c.Get("user").(*jwt.Token)
+	claims := user.Claims.(jwt.MapClaims)
+	_sha256 := sha256.Sum256([]byte(string(claims["name"].(string))))
+	var hashChannel_ = make(chan []byte, 1)
+	hashChannel_ <- _sha256[:]
+	token := decrypt(<-hashChannel_, claims["IPAToken"].(string))
+	_BA := strings.Split(token, ";")
+	BA := _BA[len(_BA)-2]
+	url := OvirtURL + "/ovirt-engine/api/vms/" + vmuuid + "/shutdown"
+	method := "POST"
+	__json:="{\"async\":\"true\"}"
+	sha256 := sha256.Sum256([]byte(vmuuid))
+	var hashChannel = make(chan []byte, 1)
+	hashChannel <- sha256[:]
+	___json := encrypt(<-hashChannel, __json)
+	startVM := addVMTask{
+		URL:     url,
+		JSON:    ___json,
+		Method:  method,
+		Headers: nil,
+	}
+	startVM.Headers = append(startVM.Headers, TaskHeader{Name: "Version", Value: "4"})
+	startVM.Headers = append(startVM.Headers, TaskHeader{Name: "Accept", Value: "application/json"})
+	startVM.Headers = append(startVM.Headers, TaskHeader{Name: "Content-Type", Value: "application/json"})
+	startVM.Headers = append(startVM.Headers, TaskHeader{Name: "Authorization", Value: BA})
+
+	//req.Header.Add("Version", "4")
+	//req.Header.Add("Accept", "application/json")
+	//req.Header.Add("Authorization", BA)
+	//req.Header.Add("Content-Type", "application/json")
+	//
+	//res, err := client.Do(req)
+	//defer res.Body.Close()
+	uuid, _ := uuidgen("APIGW-Ovirt")
+	__startVM, _ := json.MarshalIndent(startVM, "", "  ")
+	//fmt.Println("StartVMHeaders: ", string(__startVMHeaders))
+	addTask(uuid, string(__startVM), "", "APIGW", "VM Start", vmuuid, "1", "1")
+
+	resp := _response{
+		Origin:  "ovirt-StartVM",
+		Message: "Done",
+		Code:    1000,
+	}
+	b, _ := json.MarshalIndent(resp, "", "  ")
+	return c.String(http.StatusOK, string(b))
+}
+
+func (o ovirt) RebootVM(c echo.Context) error {
+	vmuuid := c.FormValue("VmUUID")
+	user := c.Get("user").(*jwt.Token)
+	claims := user.Claims.(jwt.MapClaims)
+	_sha256 := sha256.Sum256([]byte(string(claims["name"].(string))))
+	var hashChannel_ = make(chan []byte, 1)
+	hashChannel_ <- _sha256[:]
+	token := decrypt(<-hashChannel_, claims["IPAToken"].(string))
+	_BA := strings.Split(token, ";")
+	BA := _BA[len(_BA)-2]
+	url := OvirtURL + "/ovirt-engine/api/vms/" + vmuuid + "/reboot"
+	method := "POST"
+	__json:="{\"async\":\"true\"}"
+	sha256 := sha256.Sum256([]byte(vmuuid))
+	var hashChannel = make(chan []byte, 1)
+	hashChannel <- sha256[:]
+	___json := encrypt(<-hashChannel, __json)
+	startVM := addVMTask{
+		URL:     url,
+		JSON:    ___json,
+		Method:  method,
+		Headers: nil,
+	}
+	startVM.Headers = append(startVM.Headers, TaskHeader{Name: "Version", Value: "4"})
+	startVM.Headers = append(startVM.Headers, TaskHeader{Name: "Accept", Value: "application/json"})
+	startVM.Headers = append(startVM.Headers, TaskHeader{Name: "Content-Type", Value: "application/json"})
+	startVM.Headers = append(startVM.Headers, TaskHeader{Name: "Authorization", Value: BA})
+
+	//req.Header.Add("Version", "4")
+	//req.Header.Add("Accept", "application/json")
+	//req.Header.Add("Authorization", BA)
+	//req.Header.Add("Content-Type", "application/json")
+	//
+	//res, err := client.Do(req)
+	//defer res.Body.Close()
+	uuid, _ := uuidgen("APIGW-Ovirt")
+	__startVM, _ := json.MarshalIndent(startVM, "", "  ")
+	//fmt.Println("StartVMHeaders: ", string(__startVMHeaders))
+	addTask(uuid, string(__startVM), "", "APIGW", "VM Start", vmuuid, "1", "1")
+
+	resp := _response{
+		Origin:  "ovirt-StartVM",
+		Message: "Done",
+		Code:    1000,
+	}
+	b, _ := json.MarshalIndent(resp, "", "  ")
+	return c.String(http.StatusOK, string(b))
+}
+func (o ovirt) PowerOffVM(c echo.Context) error {
+	vmuuid := c.FormValue("VmUUID")
+	user := c.Get("user").(*jwt.Token)
+	claims := user.Claims.(jwt.MapClaims)
+	_sha256 := sha256.Sum256([]byte(string(claims["name"].(string))))
+	var hashChannel_ = make(chan []byte, 1)
+	hashChannel_ <- _sha256[:]
+	token := decrypt(<-hashChannel_, claims["IPAToken"].(string))
+	_BA := strings.Split(token, ";")
+	BA := _BA[len(_BA)-2]
+	url := OvirtURL + "/ovirt-engine/api/vms/" + vmuuid + "/stop"
+	method := "POST"
+	__json:="{\"async\":\"true\"}"
+	sha256 := sha256.Sum256([]byte(vmuuid))
+	var hashChannel = make(chan []byte, 1)
+	hashChannel <- sha256[:]
+	___json := encrypt(<-hashChannel, __json)
+	startVM := addVMTask{
+		URL:     url,
+		JSON:    ___json,
+		Method:  method,
+		Headers: nil,
+	}
+	startVM.Headers = append(startVM.Headers, TaskHeader{Name: "Version", Value: "4"})
+	startVM.Headers = append(startVM.Headers, TaskHeader{Name: "Accept", Value: "application/json"})
+	startVM.Headers = append(startVM.Headers, TaskHeader{Name: "Content-Type", Value: "application/json"})
+	startVM.Headers = append(startVM.Headers, TaskHeader{Name: "Authorization", Value: BA})
+
+	//req.Header.Add("Version", "4")
+	//req.Header.Add("Accept", "application/json")
+	//req.Header.Add("Authorization", BA)
+	//req.Header.Add("Content-Type", "application/json")
+	//
+	//res, err := client.Do(req)
+	//defer res.Body.Close()
+	uuid, _ := uuidgen("APIGW-Ovirt")
+	__startVM, _ := json.MarshalIndent(startVM, "", "  ")
+	//fmt.Println("StartVMHeaders: ", string(__startVMHeaders))
+	addTask(uuid, string(__startVM), "", "APIGW", "VM Start", vmuuid, "1", "1")
+
+	resp := _response{
+		Origin:  "ovirt-StartVM",
+		Message: "Done",
+		Code:    1000,
+	}
+	b, _ := json.MarshalIndent(resp, "", "  ")
+	return c.String(http.StatusOK, string(b))
+}
+
+func (o ovirt) ResetVM(c echo.Context) error {
+	resp := _response{
+		Origin:  "ovirt-ResetVM",
+		Message: "not implemented",
+		Code:    1003,
+	}
+	b, _ := json.MarshalIndent(resp, "", "  ")
+	return c.String(http.StatusOK, string(b))
+
+}
+
+func (o ovirt) AddNIC(c echo.Context) error {
+	resp := _response{
+		Origin:  "ovirt-AddNIC",
+		Message: "Done",
+		Code:    1000,
+	}
+	b, _ := json.MarshalIndent(resp, "", "  ")
+	return c.String(http.StatusOK, string(b))
+
+}
+
+func (o ovirt) AddDisk(c echo.Context) error {
+	resp := _response{
+		Origin:  "ovirt-AddDisk",
+		Message: "Done",
+		Code:    1000,
+	}
+	b, _ := json.MarshalIndent(resp, "", "  ")
+	return c.String(http.StatusOK, string(b))
+
+}
+
+func (o ovirt) EditVM(c echo.Context) error {
+	resp := _response{
+		Origin:  "ovirt-EditVM",
+		Message: "Done",
+		Code:    1000,
+	}
+	b, _ := json.MarshalIndent(resp, "", "  ")
+	return c.String(http.StatusOK, string(b))
+
+}
+
+func (o ovirt) ResetPassword(c echo.Context) error {
+	resp := _response{
+		Origin:  "ovirt-ResetPassword",
+		Message: "not implemented",
+		Code:    1003,
+	}
+	b, _ := json.MarshalIndent(resp, "", "  ")
+	return c.String(http.StatusOK, string(b))
+
+}

token.go

@@ -23,6 +23,7 @@ func generateTokenPair(user userInfo, cockieStr string) (map[string]string, erro
 	}
 	claims["sub"] = 1
 	claims["name"] = user.Result.Result.Givenname[0]
+	claims["IPAUid"] = user.Result.Result.Uidnumber[0]
 	sha256 := sha256.Sum256([]byte(user.Result.Result.Givenname[0]))
 	var hashChannel = make(chan []byte, 1)
 	hashChannel <- sha256[:]