@ -25,7 +25,6 @@ import (
"fmt"
"io"
"os"
"sync"
"time"
"github.com/shamaton/msgpackgen/msgpack"
@ -36,124 +35,9 @@ import (
"git.cacert.org/cacert-gosigner/pkg/messages"
)
type protocolState int8
const (
cmdAnnounce protocolState = iota
cmdData
respAnnounce
respData
)
var validTransitions = map [ protocolState ] protocolState {
cmdAnnounce : cmdData ,
cmdData : respAnnounce ,
respAnnounce : respData ,
respData : cmdAnnounce ,
}
var protocolStateNames = map [ protocolState ] string {
cmdAnnounce : "CMD ANNOUNCE" ,
cmdData : "CMD DATA" ,
respAnnounce : "RESP ANNOUNCE" ,
respData : "RESP DATA" ,
}
func ( p protocolState ) String ( ) string {
if name , ok := protocolStateNames [ p ] ; ok {
return name
}
return fmt . Sprintf ( "unknown %d" , p )
}
type TestCommandGenerator struct {
logger * logrus . Logger
currentCommand * protocol . Command
currentResponse * protocol . Response
commands chan * protocol . Command
lock sync . Mutex
}
func ( g * TestCommandGenerator ) CmdAnnouncement ( ) ( [ ] byte , error ) {
g . lock . Lock ( )
defer g . lock . Unlock ( )
g . currentCommand = <- g . commands
announceData , err := msgpack . Marshal ( g . currentCommand . Announce )
if err != nil {
return nil , fmt . Errorf ( "could not marshal command annoucement: %w" , err )
}
g . logger . WithField ( "announcement" , & g . currentCommand . Announce ) . Info ( "write command announcement" )
return announceData , nil
}
func ( g * TestCommandGenerator ) CmdData ( ) ( [ ] byte , error ) {
g . lock . Lock ( )
defer g . lock . Unlock ( )
cmdData , err := msgpack . Marshal ( g . currentCommand . Command )
if err != nil {
return nil , fmt . Errorf ( "could not marshal command data: %w" , err )
}
g . logger . WithField ( "command" , & g . currentCommand . Command ) . Info ( "write command data" )
return cmdData , nil
}
func ( g * TestCommandGenerator ) HandleResponseAnnounce ( frame [ ] byte ) error {
g . lock . Lock ( )
defer g . lock . Unlock ( )
var ann messages . ResponseAnnounce
if err := msgpack . Unmarshal ( frame , & ann ) ; err != nil {
return fmt . Errorf ( "could not unmarshal response announcement" )
}
g . logger . WithField ( "announcement" , & ann ) . Info ( "received response announcement" )
g . currentResponse = & protocol . Response { Announce : & ann }
return nil
}
func ( g * TestCommandGenerator ) HandleResponse ( frame [ ] byte ) error {
g . lock . Lock ( )
defer g . lock . Unlock ( )
switch g . currentResponse . Announce . Code {
case messages . RespHealth :
var response messages . HealthResponse
if err := msgpack . Unmarshal ( frame , & response ) ; err != nil {
return fmt . Errorf ( "unmarshal failed: %w" , err )
}
g . currentResponse . Response = & response
case messages . RespFetchCRL :
var response messages . FetchCRLResponse
if err := msgpack . Unmarshal ( frame , & response ) ; err != nil {
return fmt . Errorf ( "unmarshal failed: %w" , err )
}
g . currentResponse . Response = & response
}
g . logger . WithField (
"command" ,
g . currentCommand ,
) . WithField (
"response" ,
g . currentResponse ,
) . Info ( "handled health response" )
return nil
logger * logrus . Logger
commands chan * protocol . Command
}
func ( g * TestCommandGenerator ) GenerateCommands ( ctx context . Context ) error {
@ -200,7 +84,11 @@ func (g *TestCommandGenerator) GenerateCommands(ctx context.Context) error {
case <- ctx . Done ( ) :
_ = healthTimer . Stop ( )
g . logger . Info ( "stopping health check loop" )
g . logger . Info ( "stopped health check loop" )
_ = crlTimer . Stop ( )
g . logger . Info ( "stopped CRL fetch loop" )
return nil
case <- healthTimer . C :
@ -225,187 +113,169 @@ func (g *TestCommandGenerator) GenerateCommands(ctx context.Context) error {
}
type clientSimulator struct {
protocolState protocolState
logger * logrus . Logger
lock sync . Mutex
clientHandler protocol . ClientHandler
framesIn chan [ ] byte
framesOut chan [ ] byte
framer protocol . Framer
commandGenerator * TestCommandGenerator
logger * logrus . Logger
}
func ( c * clientSimulator ) writeCmdAnnouncement ( ) error {
frame , err := c . commandGenerator . CmdAnnouncement ( )
if err != nil {
return fmt . Errorf ( "could not get command annoucement: %w" , err )
}
const (
responseAnnounceTimeout = 30 * time . Second
responseDataTimeout = 2 * time . Second
)
c . logger . Trace ( "writing command announcement" )
func ( c * clientSimulator ) Run ( ctx context . Context ) error {
framerErrors := make ( chan error )
protocolErrors := make ( chan error )
generatorErrors := make ( chan error )
c . framesOut <- frame
go func ( ) {
err := c . framer . ReadFrames ( os . Stdin , c . framesIn )
if err := c . nextState ( ) ; err != nil {
return err
}
framerErrors <- err
} ( )
return nil
}
go func ( ) {
err := c . framer . WriteFrames ( os . Stdout , c . framesOut )
func ( c * clientSimulator ) writeCommand ( ) error {
frame , err := c . commandGenerator . CmdData ( )
if err != nil {
return fmt . Errorf ( "could not get command data: %w" , err )
}
framerErrors <- err
} ( )
c . logger . Trace ( "writing command data" )
go func ( ) {
clientProtocol := protocol . NewClient ( c . clientHandler , c . commandGenerator . commands , c . framesIn , c . framesOut , c . logger )
c . framesOut <- frame
err := clientProtocol . Handle ( )
if err := c . nextState ( ) ; err != nil {
return err
}
protocolErrors <- err
} ( )
return nil
}
go func ( ) {
err := c . commandGenerator . GenerateCommands ( ctx )
const responseAnnounceTimeout = 30 * time . Second
const responseDataTimeout = 2 * time . Second
generatorErrors <- err
} ( )
func ( c * clientSimulator ) handleResponseAnnounce ( ) error {
c . logger . Trace ( "waiting for response announce" )
for {
select {
case <- ctx . Done ( ) :
return nil
case err := <- framerErrors :
if err != nil {
return fmt . Errorf ( "error from framer: %w" , err )
}
select {
case frame := <- c . framesIn :
if frame == nil {
return nil
}
case err := <- generatorErrors :
if err != nil {
return fmt . Errorf ( "error from command generator: %w" , err )
}
if err := c . commandGenerator . HandleResponseAnnounce ( frame ) ; err != nil {
return fmt . Errorf ( "response announce handling failed: %w" , err )
}
return nil
case err := <- protocolErrors :
if err != nil {
return fmt . Errorf ( "error from protocol handler: %w" , err )
}
if err := c . nextState ( ) ; err != nil {
return err
return nil
}
case <- time . After ( responseAnnounceTimeout ) :
c . logger . Warn ( "response announce timeout expired" )
c . protocolState = cmdAnnounce
return nil
}
return nil
}
func ( c * clientSimulator ) handleResponseData ( ) error {
c . logger . Trace ( "waiting for response data" )
type ClientHandler struct {
logger * logrus . Logger
}
select {
case frame := <- c . framesIn :
if frame == nil {
return nil
}
func ( c ClientHandler ) Send ( command * protocol . Command , out chan [ ] byte ) error {
var (
frame [ ] byte
err error
)
if err := c . commandGenerator . HandleResponse ( frame ) ; err != nil {
return fmt . Errorf ( "response handler failed: %w" , err )
}
frame , err = msgpack . Marshal ( command . Announce )
if err != nil {
return fmt . Errorf ( "could not marshal command annoucement: %w" , err )
}
if err := c . nextState ( ) ; err != nil {
return err
}
c . logger . WithField ( "announcement" , command . Announce ) . Info ( "write command announcement" )
return nil
case <- time . After ( responseDataTimeout ) :
c . logger . Warn ( "response data timeout expired" )
c . logger . Trace ( "writing command announcement" )
c . protocolState = cmdAnnounc e
out <- frame
return nil
frame , err = msgpack . Marshal ( command . Command )
if err != nil {
return fmt . Errorf ( "could not marshal command data: %w" , err )
}
}
func ( c * clientSimulator ) Run ( ctx context . Context ) error {
c . protocolState = cmdAnnounce
errors := make ( chan error )
c . logger . WithField ( "command" , command . Command ) . Info ( "write command data" )
go func ( ) {
err := c . framer . ReadFrames ( os . Stdin , c . framesIn )
out <- frame
errors <- err
} ( )
return nil
}
go func ( ) {
err := c . framer . WriteFrames ( os . Stdout , c . framesOut )
func ( c ClientHandler ) ResponseAnnounce ( in chan [ ] byte ) ( * protocol . Response , error ) {
response := & protocol . Response { }
errors <- err
} ( )
var announce messages . ResponseAnnounce
go func ( ) {
err := c . commandGenerator . GenerateCommands ( ctx )
select {
case frame := <- in :
if err := msgpack . Unmarshal ( frame , & announce ) ; err != nil {
return nil , fmt . Errorf ( "could not unmarshal response announcement: %w" , err )
}
errors <- err
} ( )
response . Announce = & announce
for {
select {
case <- ctx . Done ( ) :
return nil
case err := <- errors :
if err != nil {
return fmt . Errorf ( "error from handler loop: %w" , err )
}
c . logger . WithField ( "announcement" , response . Announce ) . Debug ( "received response announcement" )
return nil
default :
if err := c . handleProtocolState ( ) ; err != nil {
return err
}
}
return response , nil
case <- time . After ( responseAnnounceTimeout ) :
return nil , protocol . ErrResponseAnnounceTimeoutExpired
}
}
func ( c * clientSimulator ) handleProtocolState ( ) error {
c . logger . Tracef ( "handling protocol state %s" , c . protocolState )
func ( c ClientHandler ) ResponseData ( in chan [ ] byte , response * protocol . Response ) error {
select {
case frame := <- in :
switch response . Announce . Code {
case messages . RespHealth :
var resp messages . HealthResponse
if err := msgpack . Unmarshal ( frame , & resp ) ; err != nil {
return fmt . Errorf ( "could not unmarshal health response data: %w" , err )
}
c . lock . Lock ( )
defer c . lock . Unlock ( )
response . Response = & resp
case messages . RespFetchCRL :
var resp messages . FetchCRLResponse
if err := msgpack . Unmarshal ( frame , & resp ) ; err != nil {
return fmt . Errorf ( "could not unmarshal fetch CRL response data: %w" , err )
}
switch c . protocolState {
case cmdAnnounce :
if err := c . writeCmdAnnouncement ( ) ; err != nil {
return err
}
case cmdData :
if err := c . writeCommand ( ) ; err != nil {
return err
}
case respAnnounce :
if err := c . handleResponseAnnounce ( ) ; err != nil {
return err
}
case respData :
if err := c . handleResponseData ( ) ; err != nil {
return err
response . Response = & resp
default :
return fmt . Errorf ( "unhandled response code %s" , response . Announce . Code )
}
default :
return fmt. Errorf ( "unknown protocol state %s" , c . protocolState )
case <- time . After ( responseDataTimeout ) :
return protocol . ErrResponseDataTimeoutExpired
}
return nil
}
func ( c * clientSimulator ) nextState ( ) error {
next , ok := validTransitions [ c . protocolState ]
if ! ok {
return fmt . Errorf ( "illegal protocol state %s" , c . protocolState )
}
c . protocolState = next
func ( c ClientHandler ) HandleResponse ( response * protocol . Response ) error {
c . logger . WithField ( "response" , response . Announce ) . Info ( "handled response" )
c . logger . WithField ( "response" , response ) . Debug ( "full response" )
return nil
}
func newClientHandler ( logger * logrus . Logger ) * ClientHandler {
return & ClientHandler { logger : logger }
}
func main ( ) {
logger := logrus . New ( )
logger . SetOutput ( os . Stderr )
@ -418,10 +288,11 @@ func main() {
logger : logger ,
commands : make ( chan * protocol . Command ) ,
} ,
logger : logger ,
framesIn : make ( chan [ ] byte ) ,
framesOut : make ( chan [ ] byte ) ,
framer : protocol . NewCOBSFramer ( logger ) ,
logger : logger ,
framesIn : make ( chan [ ] byte ) ,
framesOut : make ( chan [ ] byte ) ,
framer : protocol . NewCOBSFramer ( logger ) ,
clientHandler : newClientHandler ( logger ) ,
}
err := sim . Run ( context . Background ( ) )
