extensions/source/oooimprovement/onlogrotate_job.cxx

   1 /*************************************************************************
   2  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   3  *
   4  * Copyright 2008 by Sun Microsystems, Inc.
   5  *
   6  * OpenOffice.org - a multi-platform office productivity suite
   7  *
   8  * $RCSfile: onlogrotate_job.cxx,v $
   9  *
  10  * $Revision: 1.4 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  ************************************************************************/
  29
  30 // MARKER(update_precomp.py): autogen include statement, do not remove
  31 #include "precompiled_extensions.hxx"
  32
  33 #include "onlogrotate_job.hxx"
  34 #include "config.hxx"
  35 #include "logpacker.hxx"
  36 #include "logstorage.hxx"
  37 #include "soaprequest.hxx"
  38 #include "soapsender.hxx"
  39
  40 #include <com/sun/star/ucb/XSimpleFileAccess.hpp>
  41 #include <osl/mutex.hxx>
  42 #include <osl/thread.hxx>
  43 #include <osl/time.h>
  44
  45
  46 using namespace ::com::sun::star::beans;
  47 using namespace ::com::sun::star::lang;
  48 using namespace ::com::sun::star::task;
  49 using namespace ::com::sun::star::uno;
  50 using ::com::sun::star::ucb::XSimpleFileAccess;
  51 using ::rtl::OUString;
  52 using ::std::vector;
  53
  54 namespace
  55 {
  56     using namespace oooimprovement;
  57
  58     static void packLogs(const Reference<XMultiServiceFactory>& sf)
  59     {
  60         try
  61         {
  62             Config config(sf);
  63             LogPacker log_packer(sf);
  64             vector<OUString> csvfiles = LogStorage(sf).getUnzippedLogFiles();
  65             for(
  66                 vector<OUString>::iterator item = csvfiles.begin();
  67                 item!=csvfiles.end();
  68                 item++)
  69                 config.incrementEventCount(log_packer.pack(*item));
  70         } catch(...) {};
  71     };
  72
  73     static void uploadLogs(const Reference<XMultiServiceFactory>& sf)
  74     {
  75         try
  76         {
  77             Config config(sf);
  78             Reference<XSimpleFileAccess> file_access(
  79                 sf->createInstance(OUString::createFromAscii("com.sun.star.ucb.SimpleFileAccess")),
  80                 UNO_QUERY_THROW);
  81             SoapSender sender(sf, config.getSoapUrl());
  82             OUString soap_id = config.getSoapId();
  83             vector<OUString> zipfiles = LogStorage(sf).getZippedLogFiles();
  84             for(
  85                 vector<OUString>::iterator item = zipfiles.begin();
  86                 item!=zipfiles.end();
  87                 item++)
  88             {
  89                 if(config.incrementFailedAttempts(1) > 25)
  90                 {
  91                     config.giveupUploading();
  92                     LogStorage(sf).clear();
  93                     return;
  94                 }
  95                 sender.send(SoapRequest(sf, soap_id, *item));
  96                 config.incrementReportCount(1);
  97                 file_access->kill(*item);
  98                 config.resetFailedAttempts();
  99             }
 100         } catch(...) {};
 101     }
 102
 103     class OnLogRotateThread : public ::osl::Thread
 104     {
 105         public:
 106             OnLogRotateThread(Reference<XMultiServiceFactory> sf);
 107             virtual void SAL_CALL run();
 108             void disposing();
 109         private:
 110             Reference<XMultiServiceFactory> m_ServiceFactory;
 111             ::osl::Mutex m_ServiceFactoryMutex;
 112     };
 113
 114     OnLogRotateThread::OnLogRotateThread(Reference<XMultiServiceFactory> sf)
 115         : m_ServiceFactory(sf)
 116     { }
 117
 118     void SAL_CALL OnLogRotateThread::run()
 119     {
 120         {
 121             ::osl::Thread::yield();
 122             TimeValue wait_intervall = {30,0};
 123             osl_waitThread(&wait_intervall);
 124         }
 125         {
 126             ::osl::Guard< ::osl::Mutex> service_factory_guard(m_ServiceFactoryMutex);
 127             if(m_ServiceFactory.is())
 128             {
 129                 if(Config(m_ServiceFactory).getInvitationAccepted())
 130                 {
 131                     packLogs(m_ServiceFactory);
 132                     uploadLogs(m_ServiceFactory);
 133                 }
 134                 else
 135                     LogStorage(m_ServiceFactory).clear();
 136             }
 137             m_ServiceFactory.clear();
 138         }
 139     }
 140
 141     void OnLogRotateThread::disposing()
 142     {
 143         ::osl::Guard< ::osl::Mutex> service_factory_guard(m_ServiceFactoryMutex);
 144         m_ServiceFactory.clear();
 145     }
 146 }
 147
 148 namespace oooimprovement
 149 {
 150     OnLogRotateJob::OnLogRotateJob(const Reference<XComponentContext>& context)
 151         : m_ServiceFactory(Reference<XMultiServiceFactory>(
 152             context->getServiceManager()->createInstanceWithContext(
 153                 OUString::createFromAscii("com.sun.star.lang.XMultiServiceFactory"), context),
 154             UNO_QUERY))
 155     { }
 156
 157     OnLogRotateJob::OnLogRotateJob(const Reference<XMultiServiceFactory>& sf)
 158         : m_ServiceFactory(sf)
 159     { }
 160
 161     OnLogRotateJob::~OnLogRotateJob()
 162     { }
 163
 164     void SAL_CALL OnLogRotateJob::executeAsync(
 165         const Sequence<NamedValue>&,
 166         const Reference<XJobListener>& listener)
 167         throw(RuntimeException)
 168     {
 169         OnLogRotateThread* thread = new OnLogRotateThread(m_ServiceFactory);
 170         thread->create();
 171
 172         Any result;
 173         listener->jobFinished(Reference<XAsyncJob>(this), result);
 174     }
 175
 176     sal_Bool SAL_CALL OnLogRotateJob::supportsService(const OUString& service_name) throw(RuntimeException)
 177     {
 178         const Sequence<OUString> service_names(getSupportedServiceNames());
 179         for (sal_Int32 idx = service_names.getLength()-1; idx>=0; --idx)
 180             if(service_name == service_names[idx]) return sal_True;
 181         return sal_False;
 182     }
 183
 184     OUString SAL_CALL OnLogRotateJob::getImplementationName() throw(RuntimeException)
 185     { return getImplementationName_static(); }
 186
 187     Sequence<OUString> SAL_CALL OnLogRotateJob::getSupportedServiceNames() throw(RuntimeException)
 188     { return getSupportedServiceNames_static(); }
 189
 190     OUString SAL_CALL OnLogRotateJob::getImplementationName_static()
 191     { return OUString::createFromAscii("com.sun.star.comp.extensions.oooimprovement.OnLogRotateJob"); }
 192
 193     Sequence<OUString> SAL_CALL OnLogRotateJob::getSupportedServiceNames_static()
 194     {
 195         Sequence<OUString> aServiceNames(1);
 196         aServiceNames[0] = OUString::createFromAscii("com.sun.star.task.XAsyncJob");
 197         return aServiceNames;
 198     }
 199
 200     Reference<XInterface> OnLogRotateJob::Create(const Reference<XComponentContext>& context)
 201     { return *(new OnLogRotateJob(context)); }
 202
 203     Reference<XInterface> OnLogRotateJob::Create(const Reference<XMultiServiceFactory>& sf)
 204     { return *(new OnLogRotateJob(sf)); }
 205 }