view release on metacpan or  search on metacpan

lib/FIX/Lite.pm  view on Meta::CPAN

                        }
                        $sessions{$socket->peerhost().':'.$socket->peerport()}->{TargetCompID} = $parsedResp->{SenderCompID};
                        $sessions{$parsedResp->{SenderCompID}} = $socket->peerhost().':'.$socket->peerport();
                        if ( $arg{AutoLogon} ) {
                            print "AutoLogon\n" if ($arg{Debug});
                            logon($socket,
                                    SenderCompID => $parsedResp->{TargetCompID},
                                    TargetCompID => $parsedResp->{SenderCompID},
                                    TargetSubID  => $parsedResp->{SenderSubID} || 'PRICE',
                                    Debug        => $arg{Debug},
                                    WaitResponse => 0
                                 );
                        } else {
                            my $msg = $msgHandler->($parsedResp);
                            if (defined $msg->{MsgType}) {
                                request($socket,
                                        SenderCompID => $parsedResp->{TargetCompID},
                                        TargetCompID => $parsedResp->{SenderCompID},
                                        %{$msg},
                                        Debug        => $arg{Debug},
                                        WaitResponse => 0
                                );
                                if ($msg->{MsgType} eq 'Reject' or $msg->{MsgType} eq '3') {
                                    print "Client authorization failed: ".$socket->peerhost().':'.$socket->peerport()."\n";
                                    delete $sessions{delete $sessions{$socket->peerhost().':'.$socket->peerport()}};
                                    $clnSel->remove($socket);
                                    close($socket);
                                }
                            }
                        }
                    }
                    else {
                        my $msg = $msgHandler->($parsedResp);
                        if (defined $msg->{MsgType}) {
                            request($socket,
                                    SenderCompID => $parsedResp->{TargetCompID},
                                    TargetCompID => $parsedResp->{SenderCompID},
                                    %{$msg},
                                    Debug        => $arg{Debug},
                                    WaitResponse => 0
                            );
                        }
                    }

                }
                # Save the incremented MsgSeqNum for the session
                $sessions{$socket->peerhost().':'.$socket->peerport()}->{MsgSeqNum} = $MsgSeqNum;
            }
        }

        # Trigger the periodical handler
        if ( $clnSel->count() && gettimeofday - $lastPeriodicHandlerTime > $arg{Period}/1000 ) {
            $lastPeriodicHandlerTime = gettimeofday;
            my $MD = $periodicHandler->();
            if ($MD) {
                foreach my $client (keys %{$MD}) {
                    if (defined $sessions{$client}) {
                        my $socket;
                        foreach my $sck ($clnSel->can_write(0)) {
                            if ($sessions{$client} eq $sck->peerhost().':'.$sck->peerport()) {
                                print "Found alive socket ".$sck->peerhost().':'.$sck->peerport().' for client '.$client."\n" if ($arg{Debug});
                                $socket = $sck;
                                last;
                            }
                        }
                        if (! defined $socket) {
                            print "ERROR. Could not find writable socket for ". $client."\n" if ($arg{Debug});
                            next;
                        }
                        $MsgSeqNum = $sessions{$socket->peerhost().':'.$socket->peerport()}->{MsgSeqNum};
                        foreach my $msg (@{$MD->{$client}}) {
                            request($socket,
                                    SenderCompID => $arg{SenderCompID},
                                    TargetCompID => $client,
                                    %{$msg},
                                    Debug        => $arg{Debug},
                                    WaitResponse => 0
                                   )
                        }
                        $sessions{$socket->peerhost().':'.$socket->peerport()}->{MsgSeqNum} = $MsgSeqNum;
                    } else {
                        print "Got a message for dead session $client. Dropping it.\n" if ($arg{Debug});
                        next;
                    }
                }
            }
        }
        select(undef, undef, undef, 0.002);
    }
}

sub loggedIn {
    my $self = shift;
    return 1 if (defined ${*$self}->{logon}->{'MsgType'} && ${*$self}->{logon}->{'MsgType'} eq getMessageType('Logon'));
    return 0;
}

sub lastRequest {
    my $self = shift;
    my $field = shift;
    return getFieldDescription($field, ${*$self}->{request}->{$field});
}

# This sub recursively builds group and component fields
sub constructField {
    my $val = shift;
    my $field = shift;
    my @result;
    if (! ref($val)) { # if scalar value
        return getFieldNumber($field->{name})."=".getFieldValue($field->{name},$val);
    }
    elsif (ref($val) eq 'ARRAY') {
        if (! isGroup($field->{name})) {
            croak $field->{name}." is not a group field";
        }
        foreach my $entry (@{$val}) {
            foreach my $f ( @{$field->{group}} ) {
                if (defined $entry->{$f->{name}}) {
                    push @result, constructField($entry->{$f->{name}}, $f);
                } elsif ($f->{required} eq 'Y') {
                    croak "ERROR: field $f->{name} is required"