Service state file processing

cloud_print/service/win/cloud_print_service.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cloud_print/service/win/cloud_print_service.h"
 
 #include <iomanip>
 #include <iostream>
 
 #include "base/at_exit.h"
 #include "base/command_line.h"
 #include "base/file_path.h"
+#include "base/file_util.h"
 #include "base/path_service.h"
+#include "base/string_util.h"
 #include "base/win/scoped_handle.h"
 #include "cloud_print/service/win/resource.h"
+#include "cloud_print/service/win/service_state.h"
 
 namespace {
 
 const char kInstallSwitch[] = "install";
 const char kUninstallSwitch[] = "uninstall";
 const char kStartSwitch[] = "start";
 const char kStopSwitch[] = "stop";
 
 const char kServiceSwitch[] = "service";
 
 const char kUserDataDirSwitch[] = "user-data-dir";
 const char kQuietSwitch[] = "quiet";
 
+const wchar_t kServiceStateFileName[] = L"Service State";
+
 // The traits class for Windows Service.
 class ServiceHandleTraits {
  public:
   typedef SC_HANDLE Handle;
 
   // Closes the handle.
   static bool CloseHandle(Handle handle) {
     return ::CloseServiceHandle(handle) != FALSE;
   }
 
@@ skipping 52 matching lines @@
   };
 
   for (size_t i = 0; i < arraysize(kSwitchHelp); ++i) {
     std::cout << std::setiosflags(std::ios::left);
     std::cout << "  -" << std::setw(15) << kSwitchHelp[i].name;
     std::cout << kSwitchHelp[i].description << "\n";
   }
   std::cout << "\n";
 }
 
+class ServiceStateDelegate : public ServiceState::OptionsDelegate {
+ public:
+  virtual std::string GetOption(const std::string& name,
+                                const std::string& default,
+                                bool secure) {
+    std::cout << "Input \'" << name << "\'";
+    if (!default.empty()) {
+      std::cout << ", press [ENTER] to keep '";
+      std::cout << default;
+      std::cout << "'";
+    }
+    std::cout << ":";
+    std::string tmp;
+
+    if (secure) {
+      DWORD saved_mode = 0;
+      // Don't close.
+      HANDLE stdin_handle = ::GetStdHandle(STD_INPUT_HANDLE);
+      ::GetConsoleMode(stdin_handle, &saved_mode);
+      ::SetConsoleMode(stdin_handle, saved_mode & ~ENABLE_ECHO_INPUT);
+      std::getline(std::cin, tmp);
+      ::SetConsoleMode(stdin_handle, saved_mode);
+      std::cout << "\n";
+    } else {
+      std::getline(std::cin, tmp);
+    }
+    if (tmp.empty())
+      return default;
+    return tmp;
+  }
+};
+
 }  // namespace
 
 class CloudPrintServiceModule
     : public ATL::CAtlServiceModuleT<CloudPrintServiceModule, IDS_SERVICENAME> {
  public:
   typedef ATL::CAtlServiceModuleT<CloudPrintServiceModule,
                                   IDS_SERVICENAME> Base;
 
   DECLARE_REGISTRY_APPID_RESOURCEID(IDR_CLOUDPRINTSERVICE,
                                     "{8013FB7C-2E3E-4992-B8BD-05C0C4AB0627}")
@@ skipping 78 matching lines @@
     if (command_line.HasSwitch(kUninstallSwitch))
       return Uninstall() ? S_OK : E_FAIL;
 
     if (command_line.HasSwitch(kInstallSwitch)) {
       if (!command_line.HasSwitch(kUserDataDirSwitch)) {
         InvalidUsage();
         return S_FALSE;
       }
 
       FilePath data_dir = command_line.GetSwitchValuePath(kUserDataDirSwitch);
-      HRESULT hr = Install(data_dir);
+      HRESULT hr = ProcessServiceState(data_dir,
+                                       command_line.HasSwitch(kQuietSwitch));
+      if (FAILED(hr))
+        return hr;
+      hr = Install(data_dir);
       if (SUCCEEDED(hr) && command_line.HasSwitch(kStartSwitch))
         return StartService();
 
       return hr;
     }
 
     if (command_line.HasSwitch(kStartSwitch))
       return StartService();
 
     if (command_line.HasSwitch(kServiceSwitch)) {
       user_data_dir_ = command_line.GetSwitchValuePath(kUserDataDirSwitch);
       *is_service = true;
       return S_OK;
     }
 
     InvalidUsage();
     return S_FALSE;
   }
 
+  HRESULT ProcessServiceState(const FilePath& user_data_dir, bool quiet) {
+    FilePath file = user_data_dir.Append(kServiceStateFileName);
+
+    for (;;) {
+      std::string contents;
+      ServiceState service_state;
+
+      bool is_valid = file_util::ReadFileToString(file, &contents) &&
+                      service_state.FromString(contents);
+
+      std::cout << file.value() << ":\n";

[gene, 2012/05/21 23:08:06]

if (!quiet) - ???

[Vitaly Buka (NO REVIEWS), 2012/05/22 05:47:20]

Done.

+      std::cout << contents << "\n";
+
+      if (!is_valid)
+        LOG(ERROR) << "Invalid file: " << file.value();
+
+      if (quiet)
+        return is_valid ? S_OK : HRESULT_FROM_WIN32(ERROR_FILE_INVALID);
+
+      if (is_valid) {
+        std::cout << "Do you want to use this file [y/n]:";

[gene, 2012/05/21 23:08:06]

If file is not valid, shall we ask user before overwriting it?
Or may be it make sense to add a command line key which will trigger config file
creation?

[Vitaly Buka (NO REVIEWS), 2012/05/22 05:47:20]

Done.

+        for (;;) {
+          std::string input;
+          std::getline(std::cin, input);
+          StringToLowerASCII(&input);
+          if (input == "y") {
+            return S_OK;
+          } else if (input == "n") {
+            is_valid = false;
+            break;
+          }
+        }
+      }
+
+      while (!is_valid) {
+        ServiceStateDelegate delegate;
+        is_valid = service_state.Configure(&delegate);

[gene, 2012/05/21 23:08:06]

Can we call GetOption() here, and then Configure(email,password,id), instead of
current round trip?

[Vitaly Buka (NO REVIEWS), 2012/05/22 05:47:20]

Done.

+        if (is_valid) {
+          std::string new_contents = service_state.ToString();
+          if (new_contents != contents) {
+            if (file_util::WriteFile(file, new_contents.c_str(),
+                                     new_contents.size()) <= 0) {
+              return HResultFromLastError();
+            }
+          }
+        }
+      }
+    }
+
+    return S_OK;
+  }
+
   HRESULT OpenServiceManager(ServiceHandle* service_manager) {
     if (!service_manager)
       return E_POINTER;
 
     service_manager->Set(::OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS));
     if (!service_manager->IsValid())
       return HResultFromLastError();
 
     return S_OK;
   }
@@ skipping 45 matching lines @@
 
   FilePath user_data_dir_;
 };
 
 CloudPrintServiceModule _AtlModule;
 
 int main() {
   base::AtExitManager at_exit;
   return _AtlModule.WinMain(0);
 }