gos.gxml

<?xml version="1.0" encoding="UTF-8"?>
<gos>
	<!-- xml docs : http://golangserver.com/docs/markup.html -->
	<deploy>webapp</deploy>
	<port>9001</port>
	<package>if-package-is-library</package>
	<not_found>/your-404-page</not_found>
	<error>/your-500-page</error>

	<output>application.go</output>
	<domain></domain><!-- Cookie domain -->
	<var type="*MegaConfig">Config</var>
	<var type="TrLock">GL</var>
	<var type="bool">isInContainer</var>
	<import src="github.com/cheikhshift/momentum/gos.gxml"/>
	<import src="strings"/>
	<import src="math/rand"/>
	<import src="sync"/>
	<import src="github.com/cheikhshift/gos/core"/>
	<import src="flag"/>
	<import src="os"/>
	<main>	
		
	 	nobrowser := flag.Bool("nobrowser", false, "Launch without openning browser")
	 	worker := flag.Bool("worker", false, "Launch megalith instance as worker")
	 	dispaddr := flag.String("dispatcher", DefaultAddress, "Host name of dispatcher instance. Add port number as needed. ie hostname:9000")
	 	workaddr := flag.String("hostname", DefaultAddress, "Host name of worker instance. Add port number as needed. ie hostname:9000")
	 	portNumber := flag.String("port", DefaultPort, "The port number megalith will to listen on") 
	 	fws := flag.String("workspace", "megaWorkSpace", "Set instance directory") 
	 	container :=  flag.Bool("container", false, "Get Dispatcher and hostname addresses from env. variables.")

	    flag.Parse()
	    WorkerMode = *worker

	    if *container == false { 	
		 	DispatcherAddressPort = *dispaddr
		 	WorkerAddressPort = *workaddr
		 	megaWorkspace = *fws
		 	if *portNumber != DefaultPort {
		 		os.Setenv(PORT, *portNumber)
		 	}
	 	} else {
	 		DispatcherAddressPort = os.ExpandEnv("$DISPATCHER_ADDR")
	 		WorkerAddressPort = os.ExpandEnv("$WORKER_ADDR")
	 	}

	 	isInContainer = *container
		ChdirHome()

		GL = TrLock{Lock: new (sync.RWMutex)}
		
		if !WorkerMode {
			InitConfigLoad()
			if !*nobrowser {
				LaunchBrowser()
			}
			if WorkerAddressPort != DefaultAddress {
				RegisterWorker(WorkerAddressPort)
			}
	    	ticker := time.NewTicker(Checkinterval)
		    go MegaTimer(ticker)
		} else {
			SelfAnnounce(DispatcherAddressPort)
			Config = &MegaConfig{}
		}


		
	

	</main>


	<key>a very very very very secret key</key>
	
	<header> 
	<!-- Moved data types to mega_types.go -->
	</header>
	<methods>
			<func name="Mega" var="" return="(result *MegaConfig)">
				if WorkerAddressPort != DefaultAddress {
					LoadConfig(&Config)
				}
				ClearHistory()
				ShouldLock()
				defer ShouldUnlock()
				return Config
			</func>
			<func name="AddServer" var="" return="(result []Server)">
				ShouldLock()
				randint := rand.Intn(200) + 50 + len(Config.Servers) 
				genimage := fmt.Sprintf("https://picsum.photos/%v/%v",randint, randint)
				ns := Server{ID : core.NewLen(20), Nickname:"New server",Image : genimage}
				Config.Servers = append(Config.Servers, ns)
				if DispatcherAddressPort != DefaultAddress {
					ioutil.WriteFile(fmt.Sprintf(urlformat, GenLogName(ns.ID), LockExt), OK ,0700)
				}
				ShouldUnlock()
				SaveConfig(&Config);
				return Config.Servers
			</func>

			<func name="DServer" var="req Server" return="(result []Server)">
				result = []Server{}
				ShouldLock()
				for _,target := range Config.Servers {
					if target.ID != req.ID {
						result = append(result, target)
					}
				}
				DeleteLog(req.ID)
				Config.Servers = result
				ShouldUnlock()
				SaveConfig(&Config);
				return
			</func>
		    <func name="UServer" var="req Server" return="(result bool)">
				ShouldLock()
				for index,target := range Config.Servers {
					if target.ID == req.ID {
						Config.Servers[index] = req
					}
				}
				ShouldUnlock()
				SaveConfig(&Config);
				return true
			</func>

			<!-- contact funcs -->
			<func name="AddContact" var="" return="(result []Contact)">
				ShouldLock()
				nc := Contact{ID : core.NewLen(20), Nickname:"New contact"}
				Config.Contacts = append(Config.Contacts, nc)
				ShouldUnlock()
				SaveConfig(&Config);
				return Config.Contacts
			</func>

			<func name="GetLog" var="req Server" return="(result RequestLog)">
				ShouldLock()
				LoadLog(req.ID, &result)
				ShouldUnlock()
				return
			</func>

			<func name="DContact" var="req Contact" return="(result []Contact)">
				result = []Contact{}
				ShouldLock()
				for _,target := range Config.Contacts {
					if target.ID != req.ID {
						result = append(result, target)
					}
				}
				
				Config.Contacts = result
				ShouldUnlock()
				SaveConfig(&Config);
				return
			</func>
		    <func name="UContact" var="req Contact" return="(result bool)">
		    	ShouldLock()
				for index,target := range Config.Contacts {
					if target.ID == req.ID {
						Config.Contacts[index] = req
					}
				}
				ShouldUnlock()
				SaveConfig(&Config);
				return true
			</func>

			<!-- setting funcs -->
			<func name="UMail" var="req MailSettings" return="(result bool)">
				ShouldLock()
				Config.Mail = req
				ShouldUnlock()
				SaveConfig(&Config);
				return true
			</func>

			<func name="UTw" var="req TwilioInfo" return="(result bool)">
				ShouldLock()
				Config.SMS = req
				ShouldUnlock()
				SaveConfig(&Config);
				return true
			</func>
			<func name="USetting" var="req Settings" return="(result bool)">
				ShouldLock()
				Config.Misc = req
				Config.LastReset = time.Now().Unix()
				ShouldUnlock()
				SaveConfig(&Config);
				return true
			</func>
			<!-- Worker/Dispatcher functions -->
			<func name="ProcessServer" var="req string" return="(result bool)">		
				LoadConfig(&Config)
				server,index := FindServer(req)
				Process(server,index)
				return true
			</func>

			<func name="UpdateServer" var="req Server" return="(result bool)">
				ShouldLock()
				_,index := FindServer(req.ID)
				Config.Servers[index].Uptime = req.Uptime
				ShouldUnlock()
				SaveConfig(&Config)	
				return true
			</func>

			<func name="RegisterServer" var="req string" return="(result bool)">
				RegisterWorker(req)
				return true
			</func>

				<func name="UpdateKubernetes" var="req k8sConfig" return="(result bool)">
				ShouldLock()
				Config.KubeSettings = req
				ShouldUnlock()
				SaveConfig(&Config);
				return true
			</func>

			<func name="AddPod" var="req PodConfig" return="( watching []PodConfig)">
				ShouldLock()
				Config.KubeSettings.Monitoring = append(Config.KubeSettings.Monitoring, req)
				watching = Config.KubeSettings.Monitoring
				ShouldUnlock()
				SaveConfig(&Config);
				return
			</func>

			<func name="UpdatePod" var="req PodConfig" return="(result bool)">
				ShouldLock()
				for index,target := range Config.KubeSettings.Monitoring {
					if target.Name == req.Name {
						Config.KubeSettings.Monitoring[index] = req
					}
				}
				ShouldUnlock()
				SaveConfig(&Config);
				return true
			</func>

			<func name="GetPods" var="" return="(result []Pod)">
				ClearHistory()
				list,_ := RequestPods()
				return list.Items
			</func>

	</methods>

	<templates>

	</templates>
	<endpoints>

			<end path="/" type="f" >
				if strings.Contains(r.URL.Path, ".map") || strings.Contains(r.URL.Path, "web/{{ server.Image }}") {
					return true
				}
			</end>

			<!-- Deploy endpoints as functions by updating
			this configuration file's deploy tag from 'webapp' to  'faas'.
			Find more information about gos FaaS deployments here : 
			http://gophersauce.com/docs/markup.html -->
			<end path="/update/server" type="POST" >
				
				decoder := json.NewDecoder(r.Body)
				var tmvv PayloadOfRequest
				err := decoder.Decode(&tmvv)
				if err != nil {
					w.WriteHeader(http.StatusInternalServerError)
					w.Write([]byte(fmt.Sprintf("{\"error\":\"%s\"}", err.Error())))
					return true
				}
				_ = NetProcessServer(tmvv.req)
				w.Header().Set("Content-Type", "text/plain")
				w.Write(OK)
			</end>

			<end path="/mega" type="POST" >
				
				Cfg := &MegaConfig{}
				LoadConfig(&Config) 
				w.Header().Set("Content-Type", "application/json")
				retjson := []byte(mResponse(Cfg))
				w.Write(retjson)
				retjson = nil
			</end>
			<!-- End Faas functions -->
  
	</endpoints>
</gos>