Changeset 2697

Timestamp:

06/06/2010 16:30:20 (2 years ago)

Author:

chris

Message:

Initial support for command and local file completion with readline.

Improve bbackupquery command-line help.

Add -E option to disable readline/editline as it causes problems with
entering international characters on some systems (see #73).

Location:

box/trunk/bin/bbackupquery

Files:

• BackupQueries.cpp (modified) (10 diffs)
• BackupQueries.h (modified) (3 diffs)
• bbackupquery.cpp (modified) (9 diffs)

box/trunk/bin/bbackupquery/BackupQueries.cpp

@@ -67 +67 @@
 QueryCommandSpecification commands[] = 
 {
-        { "quit", "" },
-        { "exit", "" },
-        { "list", "rodIFtTash", },
-        { "pwd",  "" },
-        { "cd",   "od" },
-        { "lcd",  "" },
-        { "sh",   "" },
-        { "getobject", "" },
-        { "get",  "i" },
-        { "compare", "alcqAEQ" },
-        { "restore", "drif" },
-        { "help", "" },
-        { "usage", "m" },
-        { "undelete", "" },
-        { "delete", "" },
-        { NULL, NULL } 
+        { "quit", "", Command_Quit },
+        { "exit", "", Command_Quit },
+        { "list", "rodIFtTash", Command_List },
+        { "pwd",  "", Command_pwd },
+        { "cd",   "od", Command_cd },
+        { "lcd",  "", Command_lcd },
+        { "sh",   "", Command_sh },
+        { "getobject", "", Command_GetObject },
+        { "get",  "i", Command_Get },
+        { "compare", "alcqAEQ", Command_Compare },
+        { "restore", "drif", Command_Restore },
+        { "help", "", Command_Help },
+        { "usage", "m", Command_Usage },
+        { "undelete", "", Command_Undelete },
+        { "delete", "", Command_Delete },
+        { NULL, NULL, Command_Unknown } 
 };
 
@@ -125 +125 @@
 }
 
+BackupQueries::ParsedCommand
+BackupQueries::ParseCommand(const std::string& Command, bool isFromCommandLine)
+{
+        ParsedCommand parsed;
+        parsed.completeCommand = Command;
+        
+        // is the command a shell command?
+        if(Command[0] == 's' && Command[1] == 'h' && Command[2] == ' ' && Command[3] != '\0')
+        {
+                // Yes, run shell command
+                parsed.cmdElements[0] = "sh";
+                parsed.cmdElements[1] = Command.c_str() + 3;
+                return parsed;
+        }
+
+        // split command into components
+        const char *c = Command.c_str();
+        bool inQuoted = false;
+        bool inOptions = false;
+        
+        std::string s;
+        while(*c != 0)
+        {
+                // Terminating char?
+                if(*c == ((inQuoted)?'"':' '))
+                {
+                        if(!s.empty()) parsed.cmdElements.push_back(s);
+                        s.resize(0);
+                        inQuoted = false;
+                        inOptions = false;
+                }
+                else
+                {
+                        // No. Start of quoted parameter?
+                        if(s.empty() && *c == '"')
+                        {
+                                inQuoted = true;
+                        }
+                        // Start of options?
+                        else if(s.empty() && *c == '-')
+                        {
+                                inOptions = true;
+                        }
+                        else
+                        {
+                                if(inOptions)
+                                {
+                                        // Option char
+                                        parsed.options += *c;
+                                }
+                                else
+                                {
+                                        // Normal string char
+                                        s += *c;
+                                }
+                        }
+                }
+        
+                ++c;
+        }
+        
+        if(!s.empty())
+        {
+                parsed.cmdElements.push_back(s);
+        }
+        
+        #ifdef WIN32
+        if(isFromCommandLine)
+        {
+                std::string converted;
+                
+                if(!ConvertEncoding(parsed.completeCommand, CP_ACP, converted, 
+                        GetConsoleCP()))
+                {
+                        BOX_ERROR("Failed to convert encoding");
+                        return;
+                }
+                
+                parsed.completeCommand = converted;
+                
+                for(std::vector<std::string>::iterator 
+                        i  = parsed.cmdElements.begin();
+                        i != parsed.cmdElements.end(); i++)
+                {
+                        if(!ConvertEncoding(*i, CP_ACP, converted, 
+                                GetConsoleCP()))
+                        {
+                                BOX_ERROR("Failed to convert encoding");
+                                return;
+                        }
+                        
+                        *i = converted;
+                }
+        }
+        #endif
+        
+        return parsed;
+}
+
 // --------------------------------------------------------------------------
 //
@@ -133 +232 @@
 //
 // --------------------------------------------------------------------------
-void BackupQueries::DoCommand(const char *Command, bool isFromCommandLine)
-{
-        // is the command a shell command?
-        if(Command[0] == 's' && Command[1] == 'h' && Command[2] == ' ' && Command[3] != '\0')
+void BackupQueries::DoCommand(ParsedCommand& rCommand)
+{       
+        // Check...
+        if(rCommand.cmdElements.size() < 1)
+        {
+                // blank command
+                return;
+        }
+
+        if(rCommand.cmdElements[0] == "sh" && rCommand.cmdElements.size() == 2)
         {
                 // Yes, run shell command
-                int result = ::system(Command + 3);
+                int result = ::system(rCommand.cmdElements[1].c_str());
                 if(result != 0)
                 {
@@ -148 +253 @@
                 return;
         }
-
-        // split command into components
-        std::vector<std::string> cmdElements;
-        std::string options;
-        {
-                const char *c = Command;
-                bool inQuoted = false;
-                bool inOptions = false;
-                
-                std::string s;
-                while(*c != 0)
-                {
-                        // Terminating char?
-                        if(*c == ((inQuoted)?'"':' '))
-                        {
-                                if(!s.empty()) cmdElements.push_back(s);
-                                s.resize(0);
-                                inQuoted = false;
-                                inOptions = false;
-                        }
-                        else
-                        {
-                                // No. Start of quoted parameter?
-                                if(s.empty() && *c == '"')
-                                {
-                                        inQuoted = true;
-                                }
-                                // Start of options?
-                                else if(s.empty() && *c == '-')
-                                {
-                                        inOptions = true;
-                                }
-                                else
-                                {
-                                        if(inOptions)
-                                        {
-                                                // Option char
-                                                options += *c;
-                                        }
-                                        else
-                                        {
-                                                // Normal string char
-                                                s += *c;
-                                        }
-                                }
-                        }
-                
-                        ++c;
-                }
-                if(!s.empty()) cmdElements.push_back(s);
-        }
-        
-        #ifdef WIN32
-        if (isFromCommandLine)
-        {
-                for (std::vector<std::string>::iterator 
-                        i  = cmdElements.begin();
-                        i != cmdElements.end(); i++)
-                {
-                        std::string converted;
-                        if (!ConvertEncoding(*i, CP_ACP, converted, 
-                                GetConsoleCP()))
-                        {
-                                BOX_ERROR("Failed to convert encoding");
-                                return;
-                        }
-                        *i = converted;
-                }
-        }
-        #endif
-                
-        // Check...
-        if(cmdElements.size() < 1)
-        {
-                // blank command
-                return;
-        }
-
+                
         // Work out which command it is...
         int cmd = 0;
-        while(commands[cmd].name != 0 && ::strcmp(cmdElements[0].c_str(), commands[cmd].name) != 0)
+        while(commands[cmd].name != 0 && 
+                rCommand.cmdElements[0] != commands[cmd].name)
         {
                 cmd++;
         }
+        
         if(commands[cmd].name == 0)
         {
@@ -238 +268 @@
                 for(a = 0; alias[a] != 0; ++a)
                 {
-                        if(::strcmp(cmdElements[0].c_str(), alias[a]) == 0)
+                        if(rCommand.cmdElements[0] == alias[a])
                         {
                                 // Found an alias
@@ -245 +275 @@
                         }
                 }
-        
+        }
+                
+        if(commands[cmd].name == 0 || commands[cmd].type == Command_Unknown)
+        {
                 // No such command
-                if(alias[a] == 0)
-                {
-                        BOX_ERROR("Unrecognised command: " << Command);
-                        return;
-                }
+                BOX_ERROR("Unrecognised command: " << rCommand.cmdElements[0]);
+                return;
         }
 
         // Arguments
-        std::vector<std::string> args(cmdElements.begin() + 1, cmdElements.end());
+        std::vector<std::string> args(rCommand.cmdElements.begin() + 1,
+                rCommand.cmdElements.end());
 
         // Set up options
@@ -263 +294 @@
         {
                 // options
-                const char *c = options.c_str();
+                const char *c = rCommand.options.c_str();
                 while(*c != 0)
                 {
@@ -278 +309 @@
         }
 
-        if(cmd != Command_Quit && cmd != Command_Exit)
+        if(commands[cmd].type != Command_Quit)
         {
                 // If not a quit command, set the return code to zero
@@ -285 +316 @@
 
         // Handle command
-        switch(cmd)
+        switch(commands[cmd].type)
         {
         case Command_Quit:
-        case Command_Exit:
                 mQuitNow = true;
                 break;
@@ -349 +379 @@
                 
         default:
-                BOX_ERROR("Unknown command: " << Command);
+                BOX_ERROR("Unknown command: " << rCommand.cmdElements[0]);
                 break;
         }

box/trunk/bin/bbackupquery/BackupQueries.h

@@ -21 +21 @@
 class ExcludeList;
 
-typedef struct
-{
-        const char* name;
-        const char* opts;
-}
-QueryCommandSpecification;
-
-// Data about commands
-extern QueryCommandSpecification commands[];
-
 typedef enum
 {
-        Command_Quit = 0,
-        Command_Exit,
+        Command_Unknown = 0,
+        Command_Quit,
         Command_List,
         Command_pwd,
@@ -50 +40 @@
 }
 CommandType;
+
+typedef enum
+{
+        Complete_End = 0,
+        Complete_RemoteDir,
+        Complete_RemoteFile,
+        Complete_LocalDir,
+        Complete_LocalFile,
+        Complete_LocationName,
+        Complete_RemoteIdInCurrentDir,
+}
+CompletionType;
+
+typedef struct
+{
+        const char* name;
+        const char* opts;
+        CommandType type;
+}
+QueryCommandSpecification;
+
+// Data about commands
+extern QueryCommandSpecification commands[];
 
 extern const char *alias[];
@@ -72 +85 @@
         BackupQueries(const BackupQueries &);
 public:
-
-        void DoCommand(const char *Command, bool isFromCommandLine);
+        struct ParsedCommand
+        {
+                std::vector<std::string> cmdElements;
+                std::string options;
+                std::string completeCommand;
+        };
+
+        ParsedCommand ParseCommand(const std::string& Command,
+                bool isFromCommandLine);
+        void DoCommand(ParsedCommand& rCommand);
+        CompletionType* GetCompletionTypes(ParsedCommand& rCommand);
 
         // Ready to stop?

box/trunk/bin/bbackupquery/bbackupquery.cpp

@@ -61 +61 @@
 void PrintUsageAndExit()
 {
-        printf("Usage: bbackupquery [-q*|v*|V|W<level>] [-w] "
+        std::ostringstream out;
+        out << 
+                "Usage: bbackupquery [options] [command]...\n"
+                "\n"
+                "Options:\n"
+                "  -q         Run more quietly, reduce verbosity level by one, can repeat\n"
+                "  -Q         Run at minimum verbosity, log nothing\n"
+                "  -v         Run more verbosely, increase verbosity level by one, can repeat\n"
+                "  -V         Run at maximum verbosity, log everything\n"
+                "  -W <level> Set verbosity to error/warning/notice/info/trace/everything\n"
+                "  -w         Read/write mode, allow changes to store\n"
 #ifdef WIN32
-        "[-u] "
-#endif
-        "\n"
-        "\t[-c config_file] [-o log_file] [-O log_file_level]\n"
-        "\t[-l protocol_log_file] [commands]\n"
-        "\n"
-        "As many commands as you require.\n"
-        "If commands are multiple words, remember to enclose the command in quotes.\n"
-        "Remember to use the quit command unless you want to end up in interactive mode.\n");
+                "  -u         Enable Unicode console, requires font change to Lucida Console\n"
+#else // !WIN32
+                "  -E         Disable interactive command editing, may fix entering intl chars\n"
+#endif
+                "  -c <file>  Use the specified configuration file. If -c is omitted, the last\n"
+                "             argument is the configuration file, or else the default \n"
+                "             [" << BOX_GET_DEFAULT_BBACKUPD_CONFIG_FILE << 
+                "]\n"
+                "  -o <file>  Write logging output to specified file as well as console\n"
+                "  -O <level> Set file verbosity to error/warning/notice/info/trace/everything\n"
+                "  -l <file>  Write protocol debugging logs to specified file\n"
+                "\n"
+                "Parameters: as many commands as you like. If commands are multiple words,\n"
+                "remember to enclose the command in quotes. Remember to use the quit command\n"
+                "unless you want to end up in interactive mode.\n";
+        printf("%s", out.str().c_str());
         exit(1);
 }
@@ -121 +138 @@
 }
 
+#ifdef HAVE_RL_COMPLETION_MATCHES
+        #define RL_COMPLETION_MATCHES rl_completion_matches
+#elif defined HAVE_COMPLETION_MATCHES
+        #define RL_COMPLETION_MATCHES completion_matches
+#endif
+
 char ** bbackupquery_completion(const char *text, int start, int end)
 {
@@ -131 +154 @@
          * directory.
          */
+        #ifdef RL_COMPLETION_MATCHES
         if (start == 0)
         {
-                #ifdef HAVE_RL_COMPLETION_MATCHES
-                        matches = rl_completion_matches(text,
-                                command_generator);
-                #elif defined HAVE_COMPLETION_MATCHES
-                        matches = completion_matches(text, command_generator);
-                #endif
-        }
+                matches = RL_COMPLETION_MATCHES(text, command_generator);
+        }
+        #endif
 
         return matches;
@@ -191 +211 @@
         const char* validOpts = "qvVwuc:l:o:O:W:";
         bool unicodeConsole = false;
-#else
-        const char* validOpts = "qvVwc:l:o:O:W:";
+#elif defined HAVE_LIBREADLINE // && !WIN32
+        const char* validOpts = "qvVwEc:l:o:O:W:";
+        bool useReadline = true;
 #endif
 
@@ -286 +307 @@
                 case 'u':
                         unicodeConsole = true;
+                        break;
+#elif defined HAVE_LIBREADLINE // && !WIN32
+                case 'E':
+                        useReadline = false;
                         break;
 #endif
@@ -383 +408 @@
         // 3. Make a protocol, and handshake
         if(!quiet) BOX_INFO("Handshake with store...");
-        BackupProtocolClient connection(socket);
+        std::auto_ptr<BackupProtocolClient>
+                apConnection(new BackupProtocolClient(socket));
+        BackupProtocolClient& connection(*(apConnection.get()));
         connection.Handshake();
         
@@ -403 +430 @@
         }
         // Login -- if this fails, the Protocol will exception
-        connection.QueryLogin(conf.GetKeyValueInt("AccountNumber"),
+        connection.QueryLogin(conf.GetKeyValueUint32("AccountNumber"),
                 (readWrite)?0:(BackupProtocolClientLogin::Flags_ReadOnly));
 
@@ -417 +444 @@
                 while(c < argc && !context.Stop())
                 {
-                        context.DoCommand(argv[c++], true);
+                        BackupQueries::ParsedCommand cmd(
+                                context.ParseCommand(argv[c++], true));
+                        context.DoCommand(cmd);
                 }
         }
@@ -424 +453 @@
 
 #ifdef HAVE_LIBREADLINE
-        // Must initialise the locale before using editline's readline(),
-        // otherwise cannot enter international characters.
-        if (setlocale(LC_ALL, "") == NULL)
-        {
-                BOX_ERROR("Failed to initialise locale. International "
-                        "character support may not work.");
-        }
-
-#ifdef HAVE_READLINE_HISTORY
-        using_history();
-#endif
-        /* Allow conditional parsing of the ~/.inputrc file. */
-        rl_readline_name = "bbackupquery";
-
-        /* Tell the completer that we want a crack first. */
-        rl_attempted_completion_function = bbackupquery_completion;
-
-        char *last_cmd = 0;
-        while(!context.Stop())
-        {
-                char *command = readline("query > ");
-                if(command == NULL)
-                {
-                        // Ctrl-D pressed -- terminate now
-                        break;
-                }
-                context.DoCommand(command, false);
-                if(last_cmd != 0 && ::strcmp(last_cmd, command) == 0)
-                {
-                        free(command);
-                }
-                else
-                {
-#ifdef HAVE_READLINE_HISTORY
-                        add_history(command);
+        if (useReadline)
+        {
 #else
+        if (false)
+        {
+#endif
+                // Must initialise the locale before using editline's
+                // readline(), otherwise cannot enter international characters.
+                if (setlocale(LC_ALL, "") == NULL)
+                {
+                        BOX_ERROR("Failed to initialise locale. International "
+                                "character support may not work.");
+                }
+
+                #ifdef HAVE_READLINE_HISTORY
+                        using_history();
+                #endif
+
+                /* Allow conditional parsing of the ~/.inputrc file. */
+                rl_readline_name = strdup("bbackupquery");
+
+                /* Tell the completer that we want a crack first. */
+                rl_attempted_completion_function = bbackupquery_completion;
+                
+                char *last_cmd = 0;
+                while(!context.Stop())
+                {
+                        char *command = readline("query > ");
+                        
+                        if(command == NULL)
+                        {
+                                // Ctrl-D pressed -- terminate now
+                                break;
+                        }
+                        
+                        BackupQueries::ParsedCommand cmd(
+                                context.ParseCommand(command, false));
+                        context.DoCommand(cmd);
+                        
+                        if(last_cmd != 0 && ::strcmp(last_cmd, command) == 0)
+                        {
+                                free(command);
+                        }
+                        else
+                        {
+                                #ifdef HAVE_READLINE_HISTORY
+                                        add_history(command);
+                                #else
+                                        free(last_cmd);
+                                #endif
+                                last_cmd = command;
+                        }
+                }
+                #ifndef HAVE_READLINE_HISTORY
                         free(last_cmd);
-#endif
-                        last_cmd = command;
-                }
-        }
-#ifndef HAVE_READLINE_HISTORY
-        free(last_cmd);
-        last_cmd = 0;
-#endif
-#else
-        // Version for platforms which don't have readline by default
-        if(fileno(stdin) >= 0)
-        {
-                FdGetLine getLine(fileno(stdin));
-                while(!context.Stop())
-                {
-                        printf("query > ");
-                        fflush(stdout);
-                        std::string command(getLine.GetLine());
-                        context.DoCommand(command.c_str(), false);
-                }
-        }
-#endif
+                        last_cmd = 0;
+                #endif
+        }
+        else // !HAVE_LIBREADLINE || !useReadline
+        {
+                // Version for platforms which don't have readline by default
+                if(fileno(stdin) >= 0)
+                {
+                        FdGetLine getLine(fileno(stdin));
+                        while(!context.Stop())
+                        {
+                                printf("query > ");
+                                fflush(stdout);
+                                std::string command(getLine.GetLine());
+                                BackupQueries::ParsedCommand cmd(
+                                        context.ParseCommand(command, false));
+                                context.DoCommand(cmd);
+                        }
+                }
+        }
         
         // Done... stop nicely