CommandLine.h

Go to the documentation of this file.

#ifndef COMMANDLINE_H_
#define COMMANDLINE_H_

#include <stdio.h>
#include <termios.h>

#include "component/AsyncComponent.h"
#include "component/SyncComponent.h"
#include "data/StrValue.h"
#include "io/OutStream.h"
#include "supervisor/Command.h"
#include "utils/FastMap.h"
#include "utils/Mutex.h"
#include "utils/Timestamp.h"

#define MAX_CMDS 20

class Supervisor;
class UniversalDataReader;
class UniversalDataWriter;

class CommandLine : public AsyncComponent, public OutStream
{
public:
    CommandLine( Supervisor& supervisor );
    virtual ~CommandLine();

    void initialize();

    void run();

    void uninitialize();

    static void DoCommand( const char* command, bool forceRun );

    static void DoScheduled();

    static void DoScheduleList();

    static void DoScheduleResume();

    static void DoSchedulePause( Syslog::Severity schedulePauseSeverity, Timestamp pauseTime );

    static bool IsCommandQueued();

    virtual bool isWritable();

    virtual OutStream& write( const char* buffer, size_t num );

    void setChar( const char theChar );

    void flush();

    FILE* getOutFile()
    {
        return out_;
    }

protected:

    friend class CommandLine_Test;

    FlexArray<Command*> commands_;

    ParsedCommand parsedCommands_[MAX_CMDS];
    int parsedCommandCount_;

    Command& addCommand( const char* keyword, const char* description, bool advanced = false )
    {
        Command* command = new Command( keyword, description, advanced );
        commands_.push( command );
        return *command;
    }

    void clearParsed();

    bool findUniqueArg( char *buffer, int len );

    bool parseBufferEnd();

    void completeArg( char* buffer, int len );

    CommandSyntax* findUniqueSyntax( char *buffer, int len, bool& anyMatch );

    bool findSyntax( char* buffer, int len );

    void completeSyntax( char* buffer, int len );

    enum BurnMode
    {
        BURN_OFF,
        BURN_ON,
        BURN_SECONDS,
    };

    enum ConversationMode
    {
        CONVERSATION_SHOW,
        CONVERSATION_START,
        CONVERSATION_STOP,
    };

    enum ConfigSetMode
    {
        CONFIG_SET_LIST,
        CONFIG_SET_RELOAD,
        CONFIG_SET_CONFIG,
        CONFIG_SET_LOGGING,
    };

    enum FailComponentMode
    {
        FAIL_COMPONENT_LIST,
        FAIL_COMPONENT_SHOW,
        FAIL_COMPONENT_NONE,
        FAIL_COMPONENT_HARD,
        FAIL_COMPONENT_SOFT,
        FAIL_COMPONENT_SEGFAULT,
    };

    enum FailVariableMode
    {
        FAIL_VARIABLE_LIST,
        FAIL_VARIABLE_SHOW,
        FAIL_VARIABLE_UNAVAILABLE,
        FAIL_VARIABLE_AVAILABLE,
        FAIL_VARIABLE_INVALID,
        FAIL_VARIABLE_VALID,
    };

    enum QuickMode
    {
        QUICK_SHOW,
        QUICK_ON,
        QUICK_OFF,
    };

    enum ReportAddMode
    {
        REPORT_ADD_MOD,
        REPORT_ADD_TOUCH,
        REPORT_ADD_PERIODIC,
    };

    enum RestartType
    {
        RESTART_APPLICATION,
        RESTART_HARDWARE,
        RESTART_LOGS,
        RESTART_SYSTEM,
    };

    enum RetransmitType
    {
        RETRANSMIT_SBD,
    };

    enum ScheduleType
    {
        SCHEDULE_ASAP,
        SCHEDULE_CLEAR,
        SCHEDULE_LIST,
        SCHEDULE_NEXT,
        SCHEDULE_PAUSE,
        SCHEDULE_REMOVE,
        SCHEDULE_RESUME,
        SCHEDULE_TIME,
    };

public:

    static void CommandBang( ParsedCommand* parsedCommand, int mode );
    void commandBang( ParsedCommand* parsedCommand );
    static void CommandBurn( ParsedCommand* parsedCommand, int mode );
    void commandBurn( ParsedCommand* parsedCommand, BurnMode mode );
    static void CommandConfigSet( ParsedCommand* parsedCommand, int mode );
    void commandConfigSet( ParsedCommand* parsedCommand, ConfigSetMode mode );
    static void CommandConversation( ParsedCommand* parsedCommand, int mode );
    void commandConversation( ParsedCommand* parsedCommand, ConversationMode mode );
    static void CommandDo( ParsedCommand* parsedCommand, int mode );
    void commandDo( ParsedCommand* parsedCommand );
    static void CommandFailComponent( ParsedCommand* parsedCommand, int mode );
    void commandFailComponent( ParsedCommand* parsedCommand, FailComponentMode mode );
    static void CommandFailVariable( ParsedCommand* parsedCommand, int mode );
    void commandFailVariable( ParsedCommand* parsedCommand, FailVariableMode mode );
    static void CommandGet( ParsedCommand* parsedCommand, int mode );
    void commandGet( ParsedCommand* parsedCommand );
    static void CommandGFscan( ParsedCommand* parsedCommand, int mode );
    void commandGFscan( ParsedCommand* parsedCommand );
    static void CommandHelp( ParsedCommand* parsedCommand, int mode );
    void commandHelp( ParsedCommand* parsedCommand );
    static void CommandIbit( ParsedCommand* parsedCommand, int mode );
    void commandIbit( ParsedCommand* parsedCommand );
    static void CommandIbitMcp3553( ParsedCommand* parsedCommand, int mode );
    void commandIbitMcp3553( ParsedCommand* parsedCommand );
    static void CommandLoad( ParsedCommand* parsedCommand, int mode );
    void commandLoad( ParsedCommand* parsedCommand );
    static void CommandMaintainAdd( ParsedCommand* parsedCommand, int mode );
    void commandMaintainAdd( ParsedCommand* parsedCommand, SyncComponent::CycleOrder cycleOrder );
    static void CommandMaintainClear( ParsedCommand* parsedCommand, int mode );
    void commandMaintainClear( ParsedCommand* parsedCommand );
    static void CommandMaintainUnavailable( ParsedCommand* parsedCommand, int mode );
    void commandMaintainUnavailable( ParsedCommand* parsedCommand, SyncComponent::CycleOrder cycleOrder );
    static void CommandMaintainInvalid( ParsedCommand* parsedCommand, int mode );
    void commandMaintainInvalid( ParsedCommand* parsedCommand, SyncComponent::CycleOrder cycleOrder );
    static void CommandMaintainList( ParsedCommand* parsedCommand, int mode );
    void commandMaintainList( ParsedCommand* parsedCommand );
    static void CommandMaintainRemove( ParsedCommand* parsedCommand, int mode );
    void commandMaintainRemove( ParsedCommand* parsedCommand );
    static void CommandQuick( ParsedCommand* parsedCommand, int mode );
    void commandQuick( ParsedCommand* parsedCommand, QuickMode mode );
    static void CommandQuit( ParsedCommand* parsedCommand, int mode );
    void commandQuit( ParsedCommand* parsedCommand );
    static void CommandReportAdd( ParsedCommand* parsedCommand, int mode );
    void commandReportAdd( ParsedCommand* parsedCommand, ReportAddMode mode );
    static void CommandReportClear( ParsedCommand* parsedCommand, int mode );
    void commandReportClear( ParsedCommand* parsedCommand );
    static void CommandReportList( ParsedCommand* parsedCommand, int mode );
    void commandReportList( ParsedCommand* parsedCommand );
    static void CommandReportRemove( ParsedCommand* parsedCommand, int mode );
    void commandReportRemove( ParsedCommand* parsedCommand );
    static void CommandRestart( ParsedCommand* parsedCommand, int mode );
    void commandRestart( ParsedCommand* parsedCommand, RestartType mode );
    void commandRestartApplication( ParsedCommand* parsedCommand );
    void commandRestartHardware( ParsedCommand* parsedCommand );
    void commandRestartLogs( ParsedCommand* parsedCommand );
    void commandRestartSystem( ParsedCommand* parsedCommand );
    static void CommandResume( ParsedCommand* parsedCommand, int mode );
    void commandResume( ParsedCommand* parsedCommand );
    static void CommandRetransmit( ParsedCommand* parsedCommand, int mode );
    void commandRetransmit( ParsedCommand* parsedCommand, RetransmitType retransmitType );
    static void CommandRun( ParsedCommand* parsedCommand, int mode );
    void commandRun( ParsedCommand* parsedCommand );
    static void CommandSet( ParsedCommand* parsedCommand, int mode );
    void commandSet( ParsedCommand* parsedCommand );
    static void CommandSchedule( ParsedCommand* parsedCommand, int mode );
    void commandSchedule( ParsedCommand* parsedCommand, ScheduleType scheduleType );
    void commandSchedulePause( Syslog::Severity schedulePauseSeverity, Timestamp pauseTime );
    void commandScheduleShowPaused();
    void commandScheduleResume();
    static void CommandShowBest( ParsedCommand* parsedCommand, int mode );
    void commandShowBest( ParsedCommand* parsedCommand );
    static void CommandShowComponent( ParsedCommand* parsedCommand, int mode );
    void commandShowComponent( ParsedCommand* parsedCommand );
    static void CommandShowDependencies( ParsedCommand* parsedCommand, int mode );
    void commandShowDependencies( ParsedCommand* parsedCommand );
    static void CommandShowStack( ParsedCommand* parsedCommand, int mode );
    void commandShowStack( ParsedCommand* parsedCommand );
    static void CommandShowState( ParsedCommand* parsedCommand, int mode );
    void commandShowState( ParsedCommand* parsedCommand );
    static void CommandShowVariable( ParsedCommand* parsedCommand, int mode );
    void commandShowVariable( ParsedCommand* parsedCommand );
    static void CommandStop( ParsedCommand* parsedCommand, int mode );
    void commandStop( ParsedCommand* parsedCommand );

protected:

    static const int BUFF_SIZE = 1024;

    static char ConsoleBuffer_[BUFF_SIZE];
    static int InputIndex_;
    static char OutputBuffer_[BUFF_SIZE];
    static int OutputIndex_;

    static const int HISTORY_SIZE = 50;

    static bool AtMode_;

    static const Timespan BANG_TIMEOUT;

    bool haveTermios_;
    struct termios originalTermios_;
    struct termios newTermios_;
    Supervisor& supervisor_;
    FILE* in_;
    FILE* out_;
    const char* prompt_;
    static const size_t MAX_HOST_NAME_SIZE = 128;
    char hostname_[MAX_HOST_NAME_SIZE];

    FlexArray<Str*> cmdHistory_;
    size_t cmdHistoryIndex_;

    Mutex scheduleMutex_;

    bool gettingLines_;
    bool cmdQueued_;

    StrValue keyText_;

    Timestamp burnStopTime_;
    char doBuffer_[1024];
    size_t doBytes_;
    Str doSbd_;

    void clearLine();
    void backspace();
    void setLine( const char* line, bool allowExec );
    void execLine();

    void getLines();
    unsigned char kbGetc();
    char* nextWord( char** line );

    static char QueuedCommand_[BUFF_SIZE];
    static Mutex QueueCommandMutex_;
    static CommandLine* Instance_;

    DataReader* ibitRunningReader_;
    DataReader* scanRunningReader_;
    UniversalDataReader* platformConversationReader_;
    UniversalDataWriter* platformConversationWriter_;

private:
    // Note that the copy constructor below is private and not given a body.
    // Any attempt to call it will return a compiler error.
    CommandLine( const CommandLine& old ); // disallow copy constructor

};

#endif /*COMMANDLINE_H_*/