func (a *AlertManager) EvalNodes() {
a.alertsLock.RLock()
defer a.alertsLock.RUnlock()
for _, al := range a.alerts {
nodes := a.Graph.LookupNodesFromKey(al.Select)
for _, n := range nodes {
w := eval.NewWorld()
defConst := func(name string, val interface{}) {
t, v := toTypeValue(val)
w.DefineConst(name, t, v)
}
for k, v := range n.Metadata() {
defConst(k, v)
}
fs := token.NewFileSet()
toEval := "(" + al.Test + ") == true"
expr, err := w.Compile(fs, toEval)
if err != nil {
logging.GetLogger().Error("Can't compile expression : " + toEval)
continue
}
ret, err := expr.Run()
if err != nil {
logging.GetLogger().Error("Can't evaluate expression : " + toEval)
continue
}
if ret.String() == "true" {
al.Count++
msg := AlertMessage{
UUID: al.UUID,
Type: FIXED,
Timestamp: time.Now(),
Count: al.Count,
Reason: al.Action,
ReasonData: n,
}
logging.GetLogger().Debugf("AlertMessage to WS : " + al.UUID + " " + msg.String())
for _, l := range a.eventListeners {
l.OnAlert(&msg)
}
}
}
}
}
func main() {
w := eval.NewWorld()
w.DefineVar("connect", eval.NewFuncType([]eval.Type{}, false, []eval.Type{}), &funcV{&testFunc{}})
fmt.Println(":: welcome to go-eval...\n(hit ^D to exit)")
fd := int(os.Stdin.Fd())
oldState, err := terminal.MakeRaw(fd)
if err != nil {
panic(err)
}
defer terminal.Restore(fd, oldState)
term := terminal.NewTerminal(&shell{r: os.Stdin, w: os.Stdout}, "> ")
if term == nil {
panic(errors.New("could not create terminal"))
}
for {
line, err := term.ReadLine()
if err != nil {
break
}
code, err := w.Compile(fset, line)
if err != nil {
term.Write([]byte(err.Error() + "\n"))
continue
}
v, err := code.Run()
if err != nil {
term.Write([]byte(err.Error() + "\n"))
continue
}
if v != nil {
term.Write([]byte(v.String() + "\n"))
}
}
}
func main() {
defer atexit()
flag.Parse()
w := eval.NewWorld()
if *filename != "" {
data, err := ioutil.ReadFile(*filename)
if err != nil {
fmt.Println(err.Error())
os.Exit(1)
}
file, err := parser.ParseFile(fset, *filename, data, 0)
if err != nil {
fmt.Println(err.Error())
os.Exit(1)
}
files := []*ast.File{file}
code, err := w.CompilePackage(fset, files, "main")
if err != nil {
if list, ok := err.(scanner.ErrorList); ok {
for _, e := range list {
fmt.Println(e.Error())
}
} else {
fmt.Println(err.Error())
}
os.Exit(1)
}
code, err = w.Compile(fset, "main()")
if err != nil {
fmt.Println(err.Error())
os.Exit(1)
}
_, err = code.Run()
if err != nil {
fmt.Println(err.Error())
os.Exit(1)
}
os.Exit(0)
}
var ierr error = nil // previous interpreter error
ps1 := "igo> "
ps2 := "... "
prompt := &ps1
codelet := ""
// initialize main package
{
codelet := "package main\n"
f, err := parser.ParseFile(fset, "input", codelet, 0)
code, err := w.CompilePackage(fset, []*ast.File{f}, "main")
if err == nil {
code.Run()
}
}
for {
line, err := term.Prompt(*prompt)
if err != nil {
if err != io.EOF {
ierr = err
} else {
ierr = nil
}
break //os.Exit(0)
}
if line == "" || line == ";" {
// no more input
prompt = &ps1
}
codelet += line
if codelet != "" {
for _, ll := range strings.Split(codelet, "\n") {
term.AppendHistory(ll)
}
}
code, err := w.Compile(fset, codelet+";")
if err != nil {
if ierr != nil && prompt == &ps1 {
fmt.Println(err.Error())
fmt.Printf("(error %T)\n", err)
// reset state
codelet = ""
ierr = nil
prompt = &ps1
continue
}
// maybe multi-line command ?
prompt = &ps2
ierr = err
codelet += "\n"
continue
}
v, err := code.Run()
if err != nil {
fmt.Println(err.Error())
fmt.Printf("(error %T)\n", err)
codelet = ""
continue
}
if v != nil {
fmt.Println(v.String())
}
// resetstate:
// reset state
codelet = ""
ierr = nil
}
}
func main() {
flag.Parse()
w := eval.NewWorld()
if *filename != "" {
data, err := ioutil.ReadFile(*filename)
if err != nil {
fmt.Println(err.Error())
os.Exit(1)
}
file, err := parser.ParseFile(fset, *filename, data, 0)
if err != nil {
fmt.Println(err.Error())
os.Exit(1)
}
files := []*ast.File{file}
code, err := w.CompilePackage(fset, files, "main")
if err != nil {
if list, ok := err.(scanner.ErrorList); ok {
for _, e := range list {
fmt.Println(e.Error())
}
} else {
fmt.Println(err.Error())
}
os.Exit(1)
}
code, err = w.Compile(fset, "main()")
if err != nil {
fmt.Println(err.Error())
os.Exit(1)
}
_, err = code.Run()
if err != nil {
fmt.Println(err.Error())
os.Exit(1)
}
os.Exit(0)
}
fmt.Println(":: welcome to go-eval...\n(hit ^D to exit)")
fd := int(os.Stdin.Fd())
oldState, err := terminal.MakeRaw(fd)
if err != nil {
panic(err)
}
defer terminal.Restore(fd, oldState)
term := terminal.NewTerminal(&shell{r: os.Stdin, w: os.Stdout}, "> ")
if term == nil {
panic(errors.New("could not create terminal"))
}
for {
line, err := term.ReadLine()
if err != nil {
break
}
code, err := w.Compile(fset, line)
if err != nil {
term.Write([]byte(err.Error() + "\n"))
continue
}
if code == nil {
term.Write([]byte("failed to compile codelet\n"))
continue
}
v, err := code.Run()
if err != nil {
term.Write([]byte(err.Error() + "\n"))
continue
}
if v != nil {
term.Write([]byte(v.String() + "\n"))
}
}
}
func SetupExecutionEnvironment() {
World = eval.NewWorld()
fset = token.NewFileSet()
}