skv.sm

//
// Author: Markus Stenberg <fingon@iki.fi>
//
// Copyright (c) 2012 cisco Systems, Inc.
//

%{
        require 'skv_const'
%}

%start Client::Init
%class SKV

%map Client
%%

// State Transition End State Action(s)
Init 
Entry { init_client(skv_const.INITIAL_LISTEN_TIMEOUT); }
{
  Initialized [ctxt:is_server() ] Server::Init { }
  Initialized Connecting { }
}

Default
{
  HaveUpdate(k: Key, v:Value) nil { store_local_update(k, v); }
//  RemoveListener(l: Listener) nil { delete_listener(l); }
}

Connecting 
Entry { start_retry_timer(skv_const.CONNECT_TIMEOUT); socket_connect(); }
Exit { clear_timeout_maybe(); }
{
  Connected WaitVersion { }

  // XXX - should the failure behavior be same for failure + timeout?

  ConnectFailed [ ctxt:is_long_lived() ] Server::Init { clear_socket_maybe(); }
  ConnectFailed [ ctxt:should_auto_retry() ] ClientFailRetry { clear_socket_maybe(); }
  ConnectFailed Terminal::ClientFailConnect {  clear_socket_maybe(); }

  Timeout [ ctxt:is_long_lived() ] Server::Init { clear_socket_maybe(); }
  Timeout [ ctxt:should_auto_retry() ] ClientFailRetry { clear_socket_maybe(); }
  Timeout Terminal::ClientFailConnect {  clear_socket_maybe(); }
}

WaitVersion
Entry  { wrap_socket_json(); }
Exit { }
{
  ReceiveVersion(v: Value) [ctxt:protocol_is_current_version(v)] WaitUpdates {}
  ReceiveVersion(v: Value) Terminal::ClientFailConnect {}
  ConnectionClosed Connecting { clear_json(); }
// receiving of updates handled here; however, it doesn't affect system state machine
}

WaitUpdates
Entry  { send_local_state(); 
//send_listeners(); 
}
Exit { clear_json(); }
{
  HaveUpdate(k: Key, v:Value) nil { store_local_update(k, v); send_update_kv(k, v); }
//  AddListener(k: String, cb:Callback) nil { l = add_listener(k, cb); send_add_listener(l); }
//  RemoveListener(l: Listener) nil { send_remove_listener(l); delete_listener(l); }
  ConnectionClosed Connecting { }
  ReceiveUpdate(json:Json, k: Key, v: Value) nil { client_remote_update(json, k, v); }
}

ClientFailRetry
Entry { increase_retry_timer(); start_retry_timer(); }
Exit { clear_timeout(); }
{
  Timeout Connecting { }
}

%%

%map Server
%%

Default
{
  HaveUpdate(k: Key, v:Value) nil { store_local_update(k, v); }
//  AddListener(k: String, cb: Callback) nil { add_listener(k, cb); }
//  RemoveListener(l: Listener) nil { delete_listener(l); }
}

Init 
Entry { init_server(); }
{
  Initialized Binding {}
}

Binding 
Entry { bind(); }
{
  Bound WaitConnections { }
  BindFailed [ctxt:is_server()] Terminal::ServerBindFailed { }
  BindFailed InitWait { }  
}

InitWait
Entry { increase_retry_timer(); start_retry_timer(); }
Exit { clear_timeout(); }
{
  Timeout Client::Connecting { }
}

WaitConnections 
Entry { }
{
// new connection loop here - no affect on the state machine though
  HaveUpdate(k: Key, v:Value) nil { store_local_update(k, v); send_update_to_clients(k, v); }
  ReceiveUpdate(json:JsonCodec, k: Key, v: Value) nil { server_remote_update(json, k, v); }
}
%%

%map Terminal
%%

ClientFailConnect
Entry { fail("unable to connect to SKV"); }
{
}

ServerBindFailed
Entry { fail("unable to listen on selected port"); }
{

}

%%