func (tx *ServerTransaction) initNonInviteFSM() {
// Define States
// Trying
server_state_def_trying := fsm.State{
Index: server_state_trying,
Outcomes: map[fsm.Input]fsm.Outcome{
server_input_request: {server_state_trying, fsm.NO_ACTION},
server_input_user_1xx: {server_state_proceeding, tx.act_respond},
server_input_user_2xx: {server_state_completed, tx.act_respond},
server_input_user_300_plus: {server_state_completed, tx.act_respond},
},
}
// Proceeding
server_state_def_proceeding := fsm.State{
Index: server_state_proceeding,
Outcomes: map[fsm.Input]fsm.Outcome{
server_input_request: {server_state_proceeding, tx.act_respond},
server_input_user_1xx: {server_state_proceeding, tx.act_respond},
server_input_user_2xx: {server_state_completed, tx.act_final},
server_input_user_300_plus: {server_state_completed, tx.act_final},
server_input_transport_err: {server_state_terminated, tx.act_trans_err},
},
}
// Completed
server_state_def_completed := fsm.State{
Index: server_state_completed,
Outcomes: map[fsm.Input]fsm.Outcome{
server_input_request: {server_state_completed, tx.act_respond},
server_input_user_1xx: {server_state_completed, fsm.NO_ACTION},
server_input_user_2xx: {server_state_completed, fsm.NO_ACTION},
server_input_user_300_plus: {server_state_completed, fsm.NO_ACTION},
server_input_timer_h: {server_state_terminated, tx.act_timeout},
server_input_transport_err: {server_state_terminated, tx.act_trans_err},
},
}
// Terminated
server_state_def_terminated := fsm.State{
Index: server_state_terminated,
Outcomes: map[fsm.Input]fsm.Outcome{
server_input_request: {server_state_terminated, fsm.NO_ACTION},
server_input_user_1xx: {server_state_terminated, fsm.NO_ACTION},
server_input_user_2xx: {server_state_terminated, fsm.NO_ACTION},
server_input_user_300_plus: {server_state_terminated, fsm.NO_ACTION},
server_input_timer_h: {server_state_terminated, fsm.NO_ACTION},
server_input_delete: {server_state_terminated, tx.act_delete},
},
}
// Define FSM
fsm, err := fsm.Define(
server_state_def_trying,
server_state_def_proceeding,
server_state_def_completed,
server_state_def_terminated,
)
if err != nil {
log.Severe("Failed to define transaction FSM. Transaction will be dropped.")
return
}
tx.fsm = fsm
}
func (tx *ClientTransaction) initInviteFSM() {
// Define Actions
// Resend the request.
act_resend := func() fsm.Input {
tx.timer_a_time *= 2
tx.timer_a.Reset(tx.timer_a_time)
tx.resend()
return fsm.NO_INPUT
}
// Just pass up the latest response.
act_passup := func() fsm.Input {
tx.passUp()
return fsm.NO_INPUT
}
// Handle 300+ responses.
// Pass up response and send ACK, start timer D.
act_300 := func() fsm.Input {
tx.passUp()
tx.Ack()
if tx.timer_d != nil {
tx.timer_d.Stop()
}
tx.timer_d = time.AfterFunc(tx.timer_d_time, func() {
tx.fsm.Spin(client_input_timer_d)
})
return fsm.NO_INPUT
}
// Send an ACK.
act_ack := func() fsm.Input {
tx.Ack()
return fsm.NO_INPUT
}
// Send up transport failure error.
act_trans_err := func() fsm.Input {
tx.transportError()
return client_input_delete
}
// Send up timeout error.
act_timeout := func() fsm.Input {
tx.timeoutError()
return client_input_delete
}
// Pass up the response and delete the transaction.
act_passup_delete := func() fsm.Input {
tx.passUp()
tx.Delete()
return fsm.NO_INPUT
}
// Just delete the transaction.
act_delete := func() fsm.Input {
tx.Delete()
return fsm.NO_INPUT
}
// Define States
// Calling
client_state_def_calling := fsm.State{
Index: client_state_calling,
Outcomes: map[fsm.Input]fsm.Outcome{
client_input_1xx: {client_state_proceeding, act_passup},
client_input_2xx: {client_state_terminated, act_passup_delete},
client_input_300_plus: {client_state_completed, act_300},
client_input_timer_a: {client_state_calling, act_resend},
client_input_timer_b: {client_state_terminated, act_timeout},
client_input_transport_err: {client_state_terminated, act_trans_err},
},
}
// Proceeding
client_state_def_proceeding := fsm.State{
Index: client_state_proceeding,
Outcomes: map[fsm.Input]fsm.Outcome{
client_input_1xx: {client_state_proceeding, act_passup},
client_input_2xx: {client_state_terminated, act_passup_delete},
client_input_300_plus: {client_state_completed, act_300},
client_input_timer_a: {client_state_proceeding, fsm.NO_ACTION},
client_input_timer_b: {client_state_proceeding, fsm.NO_ACTION},
},
}
// Completed
client_state_def_completed := fsm.State{
Index: client_state_completed,
Outcomes: map[fsm.Input]fsm.Outcome{
client_input_1xx: {client_state_completed, fsm.NO_ACTION},
client_input_2xx: {client_state_completed, fsm.NO_ACTION},
client_input_300_plus: {client_state_completed, act_ack},
client_input_timer_d: {client_state_terminated, act_delete},
client_input_transport_err: {client_state_terminated, act_trans_err},
client_input_timer_a: {client_state_completed, fsm.NO_ACTION},
client_input_timer_b: {client_state_completed, fsm.NO_ACTION},
},
}
// Terminated
client_state_def_terminated := fsm.State{
Index: client_state_terminated,
Outcomes: map[fsm.Input]fsm.Outcome{
client_input_1xx: {client_state_terminated, fsm.NO_ACTION},
client_input_2xx: {client_state_terminated, fsm.NO_ACTION},
client_input_300_plus: {client_state_terminated, fsm.NO_ACTION},
client_input_timer_a: {client_state_terminated, fsm.NO_ACTION},
client_input_timer_b: {client_state_terminated, fsm.NO_ACTION},
client_input_delete: {client_state_terminated, act_delete},
},
}
fsm, err := fsm.Define(
client_state_def_calling,
client_state_def_proceeding,
client_state_def_completed,
client_state_def_terminated,
)
if err != nil {
log.Severe("Failure to define INVITE client transaction fsm: %s", err.Error())
}
tx.fsm = fsm
}
