func main() {
runtime.GOMAXPROCS(runtime.NumCPU())
mandala.Verbose = true
mandala.Debug = true
// Create rendering loop control channels
renderLoopControl := newRenderLoopControl()
// Start the rendering loop
loop.GoRecoverable(
renderLoopFunc(renderLoopControl),
func(rs loop.Recoverings) (loop.Recoverings, error) {
for _, r := range rs {
mandala.Logf("%s", r.Reason)
mandala.Logf("%s", mandala.Stacktrace())
}
return rs, fmt.Errorf("Unrecoverable loop\n")
},
)
// Start the event loop
loop.GoRecoverable(
eventLoopFunc(renderLoopControl),
func(rs loop.Recoverings) (loop.Recoverings, error) {
for _, r := range rs {
mandala.Logf("%s", r.Reason)
mandala.Logf("%s", mandala.Stacktrace())
}
return rs, fmt.Errorf("Unrecoverable loop\n")
},
)
}
// newSystemMonitor starts the system monitor.
func newSystemMonitor() *systemMonitor {
m := &systemMonitor{
measuringChan: make(chan *Measuring, 1000),
ssvChangeChan: make(chan *ssvChange, 1000),
retrieverRegistrationChan: make(chan *retrieverRegistration, 10),
commandChan: make(chan *command),
}
m.backend = loop.GoRecoverable(m.backendLoop, m.checkRecovering)
return m
}
func (t *TestSuite) BeforeAll() {
// Create rendering loop control channels
t.rlControl = newRenderLoopControl()
// Start the rendering loop
loop.GoRecoverable(
t.renderLoopFunc(t.rlControl),
func(rs loop.Recoverings) (loop.Recoverings, error) {
for _, r := range rs {
mandala.Logf("%s", r.Reason)
mandala.Logf("%s", mandala.Stacktrace())
}
return rs, fmt.Errorf("Unrecoverable loop\n")
},
)
// Start the event loop
loop.GoRecoverable(
t.eventLoopFunc(t.rlControl),
func(rs loop.Recoverings) (loop.Recoverings, error) {
for _, r := range rs {
mandala.Logf("%s", r.Reason)
mandala.Logf("%s", mandala.Stacktrace())
}
return rs, fmt.Errorf("Unrecoverable loop\n")
},
)
if t.timeout != nil {
// Start the timeout loop
loop.GoRecoverable(
t.timeoutLoopFunc(),
func(rs loop.Recoverings) (loop.Recoverings, error) {
for _, r := range rs {
mandala.Logf("%s", r.Reason)
mandala.Logf("%s", mandala.Stacktrace())
}
return rs, fmt.Errorf("Unrecoverable loop\n")
},
)
}
}
// Test regular stop of a recovered loop.
func TestStopRecoverings(t *testing.T) {
assert := asserts.NewTestingAssertion(t, true)
done := false
count := 0
l := loop.GoRecoverable(generateSimplePanicBackend(&done, &count), ignorePanics)
time.Sleep(longDelay)
assert.Nil(l.Stop(), "no error after simple stop")
assert.True(done, "backend has done")
status, _ := l.Error()
assert.Equal(loop.Stopped, status, "loop is stopped")
}
// Test error inside a recovered loop.
func TestRecoveringsError(t *testing.T) {
assert := asserts.NewTestingAssertion(t, true)
done := false
count := 0
l := loop.GoRecoverable(generateErrorPanicBackend(&done, &count), catchTimeout)
time.Sleep(longDelay)
assert.ErrorMatch(l.Stop(), "timed out", "error has to be 'timed out'")
assert.True(done, "backend has done")
status, _ := l.Error()
assert.Equal(loop.Stopped, status, "loop is stopped")
}
// Test recoverings after panics.
func TestRecoverings(t *testing.T) {
assert := asserts.NewTestingAssertion(t, true)
done := false
count := 0
l := loop.GoRecoverable(generateSimplePanicBackend(&done, &count), checkRecovering)
time.Sleep(veryLongDelay)
assert.ErrorMatch(l.Stop(), "too many panics", "error has to be 'too many panics'")
assert.True(done, "backend has done")
assert.Equal(count, 5, "loop has to be restarted 5 times")
status, _ := l.Error()
assert.Equal(loop.Stopped, status, "loop is stopped")
}
func init() {
event = make(chan interface{}, NumOfBufferedEvents)
request = make(chan interface{})
activity = make(chan unsafe.Pointer, 1)
soundCh = make(chan interface{})
loop.GoRecoverable(
resourceLoopFunc(activity, request),
func(rs loop.Recoverings) (loop.Recoverings, error) {
for _, r := range rs {
Logf("%s", r.Reason)
Logf("%s", Stacktrace())
}
return rs, fmt.Errorf("Unrecoverable loop\n")
},
)
}
func ExampleRecoverFunc() {
printChan := make(chan string)
loopFunc := func(l loop.Loop) error {
for {
select {
case <-l.ShallStop():
return nil
case str := <-printChan:
println(str)
}
}
}
recoverFunc := func(rs loop.Recoverings) (loop.Recoverings, error) {
if len(rs) >= 5 {
return nil, errors.New("too many panics")
}
return rs, nil
}
loop.GoRecoverable(loopFunc, recoverFunc)
}
//export onCreate
func onCreate(act *C.ANativeActivity, savedState unsafe.Pointer, savedStateSize C.size_t) {
defer func() {
handleCallbackError(act, recover())
}()
Debugf("onCreate...")
internalEvent = make(chan interface{})
looperCh := make(chan *C.ALooper)
// Create a new state for the current activity and store it in
// states global map.
setState(act, &state{act, nil})
// Initialize the native sound library
err := initOpenSL()
if err != nil {
Logf(err.Error())
} else {
Debugf("OpenSL successfully initialized")
}
// Initialize the native event loop
loop.GoRecoverable(
androidEventLoopFunc(internalEvent, looperCh),
func(rs loop.Recoverings) (loop.Recoverings, error) {
for _, r := range rs {
Logf("%s", r.Reason)
Logf("%s", Stacktrace())
}
return rs, fmt.Errorf("Unrecoverable loop\n")
},
)
activity <- unsafe.Pointer(act)
looper = <-looperCh
event <- CreateEvent{unsafe.Pointer(act), savedState, int(savedStateSize)}
Debugf("onCreate done.")
}
func main() {
runtime.LockOSThread()
verbose := flag.Bool("verbose", false, "produce verbose output")
debug := flag.Bool("debug", false, "produce debug output")
size := flag.String("size", "320x480", "set the size of the window")
flag.Parse()
if *verbose {
mandala.Verbose = true
}
if *debug {
mandala.Debug = true
}
dims := strings.Split(strings.ToLower(*size), "x")
width, err := strconv.Atoi(dims[0])
if err != nil {
panic(err)
}
height, err := strconv.Atoi(dims[1])
if err != nil {
panic(err)
}
if !glfw.Init() {
panic("Can't init glfw!")
}
defer glfw.Terminate()
// Enable OpenGL ES 2.0.
glfw.WindowHint(glfw.ClientApi, glfw.OpenglEsApi)
glfw.WindowHint(glfw.ContextVersionMajor, 2)
window, err := glfw.CreateWindow(width, height, "{{.AppName}}", nil, nil)
if err != nil {
panic(err)
}
mandala.Init(window)
// Create a rendering loop control struct containing a set of
// channels that control rendering.
renderLoopControl := newRenderLoopControl()
// Start the rendering loop
loop.GoRecoverable(
renderLoopFunc(renderLoopControl),
func(rs loop.Recoverings) (loop.Recoverings, error) {
for _, r := range rs {
log.Printf("%s\n%s", r.Reason, mandala.Stacktrace())
}
return rs, fmt.Errorf("Unrecoverable loop\n")
},
)
// Start the event loop
loop.GoRecoverable(
eventLoopFunc(renderLoopControl),
func(rs loop.Recoverings) (loop.Recoverings, error) {
for _, r := range rs {
log.Printf("%s\n%s", r.Reason, mandala.Stacktrace())
}
return rs, fmt.Errorf("Unrecoverable loop\n")
},
)
for !window.ShouldClose() {
glfw.WaitEvents()
}
}