Required a proper Golang Code Example documentation to use this Rulio Engine

[NehaSachan]

Hi Team,

Found very less document around this Rulio to implement in Golang.
I got a library in Golang https://godoc.org/github.com/Comcast/rulio

but how can start and how it actually takes the inputs and conditions and then will produce the results?

Please provide the way around ASAP.

[NehaSachan]

@jsccast
Please help.

[NehaSachan]

@rakesh-roshan Please help me out...

i am unable to use the rulio inside my go-program....

Below is sample code....that is very bad....
as i am unable to figure out where to start....

`package main

import (
"fmt"

ruliocore "github.com/Comcast/rulio/core"

)

func main() {

var name string = "name"
ctrl := ruliocore.DefaultControl()

ctx := ruliocore.NewContext("name")

statedata := ruliocore.State{}
location, err := ruliocore.NewLocation(ctx, name, statedata, ctrl)

var rules map[string]interface{}
res, err := location.AddRule(ctx, "location", rules)
fmt.Println("res, err ", res, err)

}
`

[NehaSachan]

@jsccast
@rakesh-roshan
@decibelcooper
@jhedlund79

Any one of you can please look into this? Please help out with this implementation issue over golang....

[jsccast]

Maybe check out the command-line program rulesys/main.go, and then consult the README for example usage. You could write your own program based on that somewhat complicated main.go.

[HemantJoshi11]

Do you still having issues

[NehaSachan]

Hi Team, Yes, i checked other Rule Engines and their example is very explanatory... But when i try to work with Rulio....i can not even start that how can I write a simple golang program which can produce a result. And i already checked the things which Jamie asked for. Please let me know any example program in golang.....which demonstrates the same.(A real example which i can run on my local machine) *Regards * *Neha Sachan*

…

On Sun, Aug 23, 2020 at 12:19 AM Hemant Joshi ***@***.***> wrote: Do you still having issues — You are receiving this because you authored the thread. Reply to this email directly, view it on GitHub <#58 (comment)>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/ALLS3CVCCEFJ2ORXWR75IY3SCAHLXANCNFSM4QBH2HKQ> .

[HemantJoshi11]

I wrote some example some time back, let me try if I can help you.

[NehaSachan]

@HemantJoshi11
can you post a sample program here ??

[HemantJoshi11]

@NehaSachan
This is not complete code but I left something for you to work on it.
I may create a pull request with an example of external source etc but that will take time.

...\rulio-poc\client-poc$ls
configuration
examples
ruleEngine

`
package main

import (
"encoding/json"
"flag"
"fmt"
"rulio-poc/client-poc/configuration"
"rulio-poc/client-poc/ruleEngine"
"rulio-poc/core"
)

func main() {

flag.Parse()
envConfig, err := configuration.ParseEnvConfiguration()
if err != nil {
	panic(fmt.Errorf("Could not parse config: %s", err))
}
fmt.Println(envConfig)
ctx := core.NewContext("main")

engine, err := ruleEngine.NewEngine(envConfig, ctx)
if err != nil {
	panic(err)
}


location := "poc"
factJson := []byte(`{<Your fact>}`)
addFact(engine, factJson, location)

ruleJson := []byte(`{"when":{"pattern":{<Your Pattern>},
	"condition":{"pattern":{<Your condition>}},
	"action":{"code":"var msg = 'code: ' + x; console.log(msg); msg;"}}`)
createRule(engine, ruleJson, location)

eventJson := []byte(`{<Your event>}`)

fmt.Println("Processing Events....")
event := make(map[string]interface{})
eventValue := make(map[string]interface{})
err = json.Unmarshal(eventJson, &eventValue)
if err != nil {
	fmt.Printf("\n Unmarshal has failed with error: %v\n", err)
}
event["event"] = eventValue
event["location"] = location
ctx = engine.Ctx.SubContext()
err = engine.Service.ProcessEvent(ctx, event)
if err != nil {
	fmt.Printf("\n Event Processing failed with error: %v\n", err)
}

}
`

`
package configuration

import "fmt"
import "github.com/kelseyhightower/envconfig"

type AppEnvConfigPoc struct {
EngineEnvConfig
GenericEnvConfig
}

type EngineEnvConfig struct {
// "linear (or indexed) state?
LinearState bool envconfig:"LinearState" default:"false"
// max pending requests; 0 means no max
MaxPending int envconfig:"max-pending" default:"0" required:"true"
// Max locations
MaxLocations int envconfig:"max-locations" default:"1000" required:"true"
// Max facts per location
MaxFacts int envconfig:"max-facts" default:"1000" required:"true"
// Log accumulator verbosity
AccVerbosity string envconfig:"acc-verbosity" default:"EVERYTHING" required:"true"
// storage type
StorageType string envconfig:"storage" default:"mem" required:"true"
// type-specific storage config
StorageConfig string envconfig:"storage-config" default:"" required:"false"
// port engine will serve
// enginePort string envconfig:"engine-port" default:"8001" required:"true"
// Location TTL, a duration, 'forever', or 'never'
LocationTTL string envconfig:"ttl" default:"forever" required:"true"
// Optional URL for external cron service"
CronURL string envconfig:"cron-url" default:"" required:"false"
// Optional URL for external cron service to reach rules engine
RulesURL string envconfig:"rules-url" default:"http://localhost:8001/" required:"true"
// Whether to check for state consistency
CheckState bool envconfig:"check-state" default:"false" required:"true"
// enable Bash script actions
BashActions bool envconfig:"bash-actions" default:"false" required:"true"
}

type GenericEnvConfig struct {
// write cpu profile to this file
CpuProfile string envconfig:"cpuprofile" default:"1000" required:"true"
// Run an HTTP server that serves profile data; 'none' to turn off
HttpProfilePort string envconfig:"httpProfilePort" default:"localhost:6060" required:"true"
// Logging verbosity.
Verbosity string envconfig:"verbosity" default:"EVERYTHING" required:"true"
// runtime.MemProfileRate
MemProfileRate int envconfig:"memProfileRate" default:"524288" required:"true"
// runtime.SetBlockProfileRate
}

func ParseEnvConfiguration() (*AppEnvConfigPoc, error) {
conf := &AppEnvConfigPoc{}
if err := envconfig.Process("", conf); err != nil {
return nil, fmt.Errorf("Environment variables are not provided: %v ", err)
}
return conf, nil
}

`

`

package ruleEngine

import (
"bytes"
"encoding/json"
"fmt"
"rulio-poc/client-poc/configuration"
"rulio-poc/core"
"rulio-poc/cron"
"rulio-poc/servicepoc"
"rulio-poc/sys"

"os/exec"
"strings"
"time"

)

type EnginePoc struct {
Ctx *core.Context
Service *servicepoc.Service
}

func NewEngine(envConfig *configuration.AppEnvConfigPoc, ctx *core.Context) (*EnginePoc, error) {

//dynamodb.CheckLastUpdated = envConfig.CheckState
inMemoryConf := sys.ExampleConfig()
if envConfig.LinearState {
	inMemoryConf.UnindexedState = true
}
inMemoryConf.Storage = envConfig.StorageType
inMemoryConf.StorageConfig = envConfig.StorageConfig

cont := sys.ExampleSystemControl()
cont.MaxLocations = envConfig.MaxLocations
ttl, err := sys.ParseLocationTTL(envConfig.LocationTTL)
if err != nil {
	return nil, err
}
cont.LocationTTL = ttl

// ToDo: Expose this internal cron limit
var cronner cron.Cronner
if envConfig.CronURL == "" {
	// Here we're using a single internal cron for all
	// served locations.  That's not (according to the
	// nice comments in cron.go) ideal.  However, it's (a)
	// easy and (b) not used in production server-side
	// deployments, which will use an external cron, which
	// provides persistency.
	cr, _ := cron.NewCron(nil, time.Second, "intcron", 1000000)
	go cr.Start(ctx)
	cronner = &cron.InternalCron{Cron: cr}
} else {
	cronner = &cron.CroltSimple{
		CroltURL: envConfig.CronURL,
		RulesURL: envConfig.RulesURL,
	}
}

verb, err := core.ParseVerbosity(envConfig.Verbosity)
if err != nil {
	panic(err)
}
locCtl := &core.Control{
	MaxFacts:  envConfig.MaxFacts,
	Verbosity: verb,
}
if envConfig.BashActions {
	locCtl.ActionInterpreters = map[string]core.ActionInterpreter{
		"bash": &BashActionInterpreter{},
	}
}
cont.DefaultLocControl = locCtl

// TODO: New system is being created
sys, err := sys.NewSystem(ctx, *inMemoryConf, *cont, cronner)
if err != nil {
	return nil, err
}
ctx.SetLogValue("app.id", "rulesys")
core.UseCores(ctx, false)
ctx.Verbosity = verb
ctx.LogAccumulatorLevel = verb

engineService := &servicepoc.Service{
	System:  sys,
	Router:  nil,
	Stopper: nil,
}
//engineService.Start(ctx, envConfig.RulesURL)
return &EnginePoc{Ctx: ctx, Service: engineService}, nil

}

type BashActionInterpreter struct {
}

func (i *BashActionInterpreter) GetName() string {
return "bash"
}

func (i *BashActionInterpreter) GetThunk(ctx *core.Context, loc *core.Location, bs core.Bindings, a core.Action) (func() (interface{}, error), error) {

return func() (interface{}, error) {
	core.Log(core.DEBUG, ctx, "BashActionIntpreter.GetThunk", "action", a, "bs", bs)
	code, err := core.GetCode(a.Code)
	if err != nil {
		return nil, err
	}

	env := make([]string, 0, len(bs))
	for p, v := range bs {
		p = strings.ToUpper(p[1:])
		if p == "EVENT" {
			js, err := json.Marshal(&v)
			if err != nil {
				return nil, err
			}
			v = string(js)
		}
		env = append(env, fmt.Sprintf("_%s=%s", p, v))
	}

	cmd := exec.Command("bash")
	cmd.Stdin = strings.NewReader(code)
	cmd.Env = env
	var out bytes.Buffer
	cmd.Stdout = &out
	if err = cmd.Run(); err != nil {
		core.Log(core.INFO, ctx, "BashActionIntpreter.GetThunk", "action", a, "error", err)
		return nil, err
	}
	return out.String(), nil
}, nil

}
`

[jsccast]

Thanks for putting together this example!

[HemantJoshi11]

welcome @jsccast. I will create PR having a complete example with external service etc so that others can learn quickly.