src/apps/haikudepot/server/BulkLoadStateMachine.cpp

   1 /*
   2  * Copyright 2017, Andrew Lindesay <apl@lindesay.co.nz>.
   3  * All rights reserved. Distributed under the terms of the MIT License.
   4  */
   5 #include "BulkLoadStateMachine.h"
   6
   7 #include <Autolock.h>
   8 #include <NetworkInterface.h>
   9 #include <NetworkRoster.h>
  10
  11 #include "Logger.h"
  12 #include "PkgDataUpdateProcess.h"
  13 #include "RepositoryDataUpdateProcess.h"
  14 #include "ServerIconExportUpdateProcess.h"
  15 #include "ServerSettings.h"
  16
  17
  18 BulkLoadStateMachine::BulkLoadStateMachine(Model* model)
  19         :
  20         fBulkLoadContext(NULL),
  21         fModel(model)
  22 {
  23 }
  24
  25
  26 BulkLoadStateMachine::~BulkLoadStateMachine()
  27 {
  28         Stop();
  29 }
  30
  31
  32 bool
  33 BulkLoadStateMachine::IsRunning()
  34 {
  35         BAutolock locker(&fLock);
  36         return fBulkLoadContext != NULL;
  37 }
  38
  39
  40 /*! This gets invoked when one of the background processes has exited. */
  41
  42 void
  43 BulkLoadStateMachine::ServerProcessExited()
  44 {
  45         ContextPoll();
  46 }
  47
  48
  49 static const char* bulk_load_state_name(bulk_load_state state) {
  50         switch(state) {
  51                 case BULK_LOAD_INITIAL:
  52                         return "BULK_LOAD_INITIAL";
  53                 case BULK_LOAD_REPOSITORY_AND_REFERENCE:
  54                         return "BULK_LOAD_REPOSITORY_AND_REFERENCE";
  55                 case BULK_LOAD_PKGS_AND_ICONS:
  56                         return "BULK_LOAD_PKGS_AND_ICONS";
  57                 case BULK_LOAD_COMPLETE:
  58                         return "BULK_LOAD_COMPLETE";
  59                 default:
  60                         return "???";
  61         }
  62 }
  63
  64
  65 void
  66 BulkLoadStateMachine::SetContextState(bulk_load_state state)
  67 {
  68         if (Logger::IsDebugEnabled()) {
  69                 printf("bulk load - transition to state [%s]\n",
  70                         bulk_load_state_name(state));
  71         }
  72
  73         fBulkLoadContext->SetState(state);
  74 }
  75
  76
  77 /*! Bulk loading data into the model can be considered to be a state
  78     machine.  This method is invoked each time that an event state
  79     change happens.
  80  */
  81
  82 void
  83 BulkLoadStateMachine::ContextPoll()
  84 {
  85         BAutolock locker(&fLock);
  86
  87         if (Logger::IsDebugEnabled())
  88                 printf("bulk load - context poll\n");
  89
  90         if (CanTransitionTo(BULK_LOAD_REPOSITORY_AND_REFERENCE)) {
  91                 SetContextState(BULK_LOAD_REPOSITORY_AND_REFERENCE);
  92                 InitiateBulkPopulateIcons();
  93                 if (InitiateBulkRepositories() != B_OK)
  94                         ContextPoll();
  95                 return;
  96         }
  97
  98         if (CanTransitionTo(BULK_LOAD_PKGS_AND_ICONS)) {
  99                 fModel->LogDepotsWithNoWebAppRepositoryCode();
 100                 SetContextState(BULK_LOAD_PKGS_AND_ICONS);
 101                 InitiateBulkPopulatePackagesForAllDepots();
 102                 return;
 103         }
 104
 105         if (CanTransitionTo(BULK_LOAD_COMPLETE)) {
 106                 SetContextState(BULK_LOAD_COMPLETE);
 107                 delete fBulkLoadContext;
 108                 fBulkLoadContext = NULL;
 109                 return;
 110         }
 111 }
 112
 113
 114 bool
 115 BulkLoadStateMachine::CanTransitionTo(bulk_load_state targetState)
 116 {
 117         if (fBulkLoadContext != NULL) {
 118                 bulk_load_state existingState = fBulkLoadContext->State();
 119
 120                 switch (targetState) {
 121                         case BULK_LOAD_INITIAL:
 122                                 return false;
 123                         case BULK_LOAD_REPOSITORY_AND_REFERENCE:
 124                                 return existingState == BULK_LOAD_INITIAL;
 125                         case BULK_LOAD_PKGS_AND_ICONS:
 126                                 return (existingState == BULK_LOAD_REPOSITORY_AND_REFERENCE)
 127                                         && ((fBulkLoadContext->RepositoryProcess() == NULL)
 128                                                 || !fBulkLoadContext->RepositoryProcess()->IsRunning());
 129                         case BULK_LOAD_COMPLETE:
 130                                 if ((existingState == BULK_LOAD_PKGS_AND_ICONS)
 131                                         && ((fBulkLoadContext->IconProcess() == NULL)
 132                                                 || !fBulkLoadContext->IconProcess()->IsRunning())) {
 133                                         int32 i;
 134
 135                                         for (i = 0; i < fBulkLoadContext->CountPkgProcesses(); i++) {
 136                                                 AbstractServerProcess* process =
 137                                                         fBulkLoadContext->PkgProcessAt(i);
 138                                                 if (process->IsRunning())
 139                                                         return false;
 140                                         }
 141
 142                                         return true;
 143                                 }
 144                                 break;
 145                 }
 146         }
 147
 148         return false;
 149 }
 150
 151
 152 void
 153 BulkLoadStateMachine::StopAllProcesses()
 154 {
 155         BAutolock locker(&fLock);
 156
 157         if (fBulkLoadContext != NULL) {
 158                 if (NULL != fBulkLoadContext->IconProcess())
 159                         fBulkLoadContext->IconProcess()->Stop();
 160
 161                 if (NULL != fBulkLoadContext->RepositoryProcess())
 162                         fBulkLoadContext->RepositoryProcess()->Stop();
 163
 164                 int32 i;
 165
 166                 for(i = 0; i < fBulkLoadContext->CountPkgProcesses(); i++) {
 167                         AbstractServerProcess* serverProcess =
 168                                 fBulkLoadContext->PkgProcessAt(i);
 169                         serverProcess->Stop();
 170                 }
 171         }
 172 }
 173
 174
 175 void
 176 BulkLoadStateMachine::Start()
 177 {
 178         if (Logger::IsInfoEnabled())
 179                 printf("bulk load - start\n");
 180
 181         Stop();
 182
 183         {
 184                 BAutolock locker(&fLock);
 185
 186                 if (!IsRunning()) {
 187                         fBulkLoadContext = new BulkLoadContext();
 188
 189                         if (ServerSettings::ForceNoNetwork() || !HasNetwork())
 190                                 fBulkLoadContext->AddProcessOption(
 191                                         SERVER_PROCESS_NO_NETWORKING);
 192
 193                         if (ServerSettings::PreferCache())
 194                                 fBulkLoadContext->AddProcessOption(SERVER_PROCESS_PREFER_CACHE);
 195
 196                         if (ServerSettings::DropCache())
 197                                 fBulkLoadContext->AddProcessOption(SERVER_PROCESS_DROP_CACHE);
 198
 199                         ContextPoll();
 200                 }
 201         }
 202 }
 203
 204
 205 void
 206 BulkLoadStateMachine::Stop()
 207 {
 208         StopAllProcesses();
 209
 210         // spin lock to wait for the bulk-load processes to complete.
 211
 212         while (IsRunning())
 213                 snooze(500000);
 214 }
 215
 216
 217 /*! This method is the initial function that is invoked on starting a new
 218     thread.  It will start a server process that is part of the bulk-load.
 219  */
 220
 221 status_t
 222 BulkLoadStateMachine::StartProcess(void* cookie)
 223 {
 224         AbstractServerProcess* process =
 225                 static_cast<AbstractServerProcess*>(cookie);
 226
 227         if (Logger::IsInfoEnabled()) {
 228                 printf("bulk load - starting process [%s]\n",
 229                         process->Name());
 230         }
 231
 232         process->Run();
 233         return B_OK;
 234 }
 235
 236
 237 status_t
 238 BulkLoadStateMachine::InitiateServerProcess(AbstractServerProcess* process)
 239 {
 240         if (Logger::IsInfoEnabled())
 241                 printf("bulk load - initiating [%s]\n", process->Name());
 242
 243         thread_id tid = spawn_thread(&StartProcess,
 244                 process->Name(), B_NORMAL_PRIORITY, process);
 245
 246         if (tid >= 0) {
 247                 resume_thread(tid);
 248                 return B_OK;
 249         }
 250
 251         return B_ERROR;
 252 }
 253
 254
 255 status_t
 256 BulkLoadStateMachine::InitiateBulkRepositories()
 257 {
 258         status_t result = B_OK;
 259         BPath dataPath;
 260
 261         fBulkLoadContext->SetRepositoryProcess(NULL);
 262         result = fModel->DumpExportRepositoryDataPath(dataPath);
 263
 264         if (result != B_OK) {
 265                 BAutolock locker(&fLock);
 266                 printf("unable to obtain the path for storing the repository data\n");
 267                 ContextPoll();
 268                 return B_ERROR;
 269         }
 270
 271         fBulkLoadContext->SetRepositoryProcess(
 272                 new RepositoryDataUpdateProcess(this, dataPath, fModel,
 273                         fBulkLoadContext->ProcessOptions()));
 274         return InitiateServerProcess(fBulkLoadContext->RepositoryProcess());
 275 }
 276
 277
 278 status_t
 279 BulkLoadStateMachine::InitiateBulkPopulateIcons()
 280 {
 281         BPath path;
 282
 283         if (fModel->IconStoragePath(path) != B_OK) {
 284                 BAutolock locker(&fLock);
 285                 printf("unable to obtain the path for storing icons\n");
 286                 ContextPoll();
 287                 return B_ERROR;
 288         }
 289
 290         AbstractServerProcess *process = new ServerIconExportUpdateProcess(
 291                 this, path, fModel, fBulkLoadContext->ProcessOptions());
 292         fBulkLoadContext->SetIconProcess(process);
 293         return InitiateServerProcess(process);
 294 }
 295
 296
 297 status_t
 298 BulkLoadStateMachine::InitiateBulkPopulatePackagesForDepot(
 299         const DepotInfo& depotInfo)
 300 {
 301         BString repositorySourceCode = depotInfo.WebAppRepositorySourceCode();
 302
 303         if (repositorySourceCode.Length() == 0) {
 304                 printf("the depot [%s] has no repository source code\n",
 305                         depotInfo.Name().String());
 306                 return B_ERROR;
 307         }
 308
 309         BPath repositorySourcePkgDataPath;
 310
 311         if (fModel->DumpExportPkgDataPath(repositorySourcePkgDataPath,
 312                 repositorySourceCode) != B_OK) {
 313                 BAutolock locker(&fLock);
 314                 printf("unable to obtain the path for storing data for [%s]\n",
 315                         repositorySourceCode.String());
 316                 ContextPoll();
 317                 return B_ERROR;
 318         }
 319
 320         AbstractServerProcess *process = new PkgDataUpdateProcess(
 321                 this, repositorySourcePkgDataPath, fModel->PreferredLanguage(),
 322                 repositorySourceCode, depotInfo.Name(), fModel,
 323                 fBulkLoadContext->ProcessOptions());
 324         fBulkLoadContext->AddPkgProcess(process);
 325
 326         return InitiateServerProcess(process);
 327 }
 328
 329
 330 // static
 331 void
 332 BulkLoadStateMachine::InitiatePopulatePackagesForDepotCallback(
 333         const DepotInfo& depotInfo, void* context)
 334 {
 335         BulkLoadStateMachine* stateMachine =
 336                 static_cast<BulkLoadStateMachine*>(context);
 337         stateMachine->InitiateBulkPopulatePackagesForDepot(depotInfo);
 338 }
 339
 340
 341 void
 342 BulkLoadStateMachine::InitiateBulkPopulatePackagesForAllDepots()
 343 {
 344         fModel->ForAllDepots(&InitiatePopulatePackagesForDepotCallback, this);
 345
 346         printf("did initiate populate package data for %" B_PRId32 " depots\n",
 347                 fBulkLoadContext->CountPkgProcesses());
 348
 349         if (0 == fBulkLoadContext->CountPkgProcesses())
 350                 ContextPoll();
 351 }
 352
 353
 354 bool
 355 BulkLoadStateMachine::HasNetwork()
 356 {
 357         BNetworkRoster& roster = BNetworkRoster::Default();
 358         BNetworkInterface interface;
 359         uint32 cookie = 0;
 360         while (roster.GetNextInterface(&cookie, interface) == B_OK) {
 361                 uint32 flags = interface.Flags();
 362                 if ((flags & IFF_LOOPBACK) == 0
 363                         && (flags & (IFF_UP | IFF_LINK)) == (IFF_UP | IFF_LINK)) {
 364                         return true;
 365                 }
 366         }
 367
 368         return false;
 369 }