00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022 #include <extern.h>
00023 #include <iostream>
00024 #include <string.h>
00025 #include <signal.h>
00026 #include <execinfo.h>
00027
00028
00029 #include <stdlib.h>
00030 #include <unistd.h>
00031 #include <netinet/in.h>
00032 #include <getopt.h>
00033
00034 #include <vsisemaphore.h>
00035
00036 #include <sys/socket.h>
00037 #include <arpa/inet.h>
00038
00039
00040 #include <sys/syscall.h>
00041
00042 #include "../interface/RioError.h"
00043
00044
00045 #include "../interface/RioTypes.h"
00046
00047 #include "token.h"
00048
00049 static char Usage[] =
00050 "[-h] "
00051 "[-n disks] "
00052 "[-p prefix directory] "
00053 "[-v]"
00054 "<devices> \n";
00055
00056 static char Usage2[] =
00057 " -h|--help\n"
00058 " Prints this message and exit\n"
00059 " -n|--ndisks <number_of_disks>\n"
00060 " Number of disks to use. Default: 1\n"
00061 " -p|--prefixdirectory <prefix directory>\n"
00062 " Set the prefix directory of config files and logs.\n"
00063 " -v|--version\n"
00064 " Show version number and exit\n"
00065 " <disk_devices>\n"
00066 " List of disk devices (or file) names\n";
00067
00068
00069
00070
00071
00072 struct StorageServerConfig
00073 {
00074 int Buffers;
00075 char *CollectMeasures;
00076 double EstimatedParameter;
00077 int SendFlag;
00078 int MaxClientsCredits;
00079 int MaxNetworkCredits;
00080 int RouterPort;
00081 int NetworkRate;
00082 int DiskThreads;
00083
00084
00085 unsigned int MaxLogFileSize;
00086
00087
00088
00089 unsigned long long int MaxCombinedLogFilesSize;
00090
00091
00092 char *SaveLogs;
00093
00094
00095 unsigned int ClientsTimeOut;
00096 };
00097
00098
00099
00100 const char* const CONFIGSSUBDIR = "etc/RIO/";
00101
00102
00103 const char* const LOGSSUBDIR = "var/log/RIO/";
00104
00105 const char* const CONFIGNAME = "RIOstorage.cfg";
00106
00107 void usage( char *progname )
00108 {
00109 RioErr << "Usage: " << endl;
00110 RioErr << " " << progname << " " << Usage;
00111 RioErr << Usage2 << endl;
00112 }
00113
00114 CvsiSemaphore Finish(0);
00115
00116
00117
00118
00119 void show_stackframe()
00120 {
00121 void *trace[16];
00122 char **messages = (char **)NULL;
00123 int i, trace_size = 0;
00124
00125 trace_size = backtrace( trace, 16 );
00126 messages = backtrace_symbols( trace, trace_size );
00127 RioErr << "[bt] Execution path:" << endl;
00128 for( i = 0; i < trace_size; ++i )
00129 RioErr << "[bt(" << i << "/" << trace_size << ")] " << messages[i]
00130 << endl;
00131 }
00132
00133 void segfaultHandler( int sig )
00134 {
00135 RioErr << "[Storage-main] SEGMENTATION FAULT!" << endl;
00136 show_stackframe();
00137
00138 _exit( 1 );
00139 }
00140
00141
00142 void signalHandler( int sig )
00143 {
00144 RioErr << "[Storage] CAUGHT SIGTERM SIGNAL!" << endl;
00145
00146 NetManager.setLogRotation( NULL );
00147
00148 Finish.V();
00149
00150
00151 exit( 2 );
00152 }
00153
00154
00155
00156
00157
00158
00159 void PrintConfiguration( StorageServerConfig *Config )
00160 {
00161 cout << "---------------------------------------------------" << endl;
00162 cout << " RIO Storage Configuration " << endl;
00163 cout << "---------------------------------------------------" << endl;
00164 cout << "Buffers\t\t\t" << Config->Buffers << endl;
00165 cout << "CollectMeasures\t\t" << Config->CollectMeasures << endl;
00166 cout << "EstimatedTime\t\t" << Config->EstimatedParameter << endl;
00167 cout << "SendBlocksFlag\t\t" << Config->SendFlag << endl;
00168 cout << "MaxClientsCredits\t" << Config->MaxClientsCredits << endl;
00169 cout << "MaxNetworkCredits\t" << Config->MaxNetworkCredits << endl;
00170 cout << "RouterPort\t\t" << Config->RouterPort << endl;
00171 cout << "NetworkRate\t\t" << Config->NetworkRate << endl;
00172 cout << "DiskThreads\t\t" << Config->DiskThreads << endl;
00173
00174
00175
00176 cout << "MaxLogFileSize\t\t" << Config->MaxLogFileSize / 1024 << " Kbytes"
00177 << endl;
00178 cout << "MaxCombinedLogFilesSize\t" << Config->MaxCombinedLogFilesSize / 1024
00179 << " Kbytes" << endl;
00180
00181
00182 if( Config->SaveLogs != NULL )
00183 cout << "LogRotation \t\t" << Config->SaveLogs << endl;
00184 else
00185 cout << "LogRotation \t\tOn" << endl;
00186
00187
00188 cout << "ClientsTimeOut\t\t" << Config->ClientsTimeOut << " seconds."
00189 << endl;
00190 cout << "---------------------------------------------------" << endl;
00191 }
00192
00193
00194 int CheckConfiguration( StorageServerConfig *Config )
00195 {
00196
00197 if( Config->Buffers <= 0 )
00198 {
00199
00200
00201
00202 Config->Buffers = ( ( 20 + 1 ) * 100 + 10 ) * 1;
00203 }
00204
00205 if( ( strcasecmp( Config->CollectMeasures, "on" ) != 0 ) &&
00206 ( strcasecmp( Config->CollectMeasures, "off" ) != 0 ))
00207 {
00208 RioErr << "ERROR: CheckConfiguration "
00209 << "CollectMeasures: " << Config->CollectMeasures
00210 << " invalid (must be 'on' or 'off')" << endl;
00211 return ( 1 );
00212 }
00213
00214 if( ( Config->EstimatedParameter < 0 ) ||
00215 ( Config->EstimatedParameter > 1 ) )
00216 {
00217 RioErr << "ERROR: CheckConfiguration Invalid EstimatedParameter: "
00218 << Config->EstimatedParameter << endl;
00219 return ( 1 );
00220 }
00221
00222 if( ( Config->SendFlag != 1 ) && ( Config->SendFlag != 0 ) )
00223 {
00224 Config->SendFlag = 1;
00225 }
00226
00227 if( Config->MaxClientsCredits <= 0 )
00228 {
00229 RioErr << "ERROR: CheckConfiguration Invalid number of client credits: "
00230 << Config->MaxClientsCredits << endl;
00231 return ( 1 );
00232 }
00233
00234 if( Config->MaxNetworkCredits <= 0 )
00235 {
00236 RioErr << "ERROR: CheckConfiguration Invalid number of network "
00237 << "credits: " << Config->MaxNetworkCredits << endl;
00238 return ( 1 );
00239 }
00240
00241 if( ( Config->RouterPort <= 0) || ( Config->RouterPort > 0xffff ) )
00242 {
00243 RioErr << "ERROR: CheckConfiguration Invalid port number: "
00244 << Config->RouterPort << endl;
00245 return( 1 );
00246 }
00247
00248 if( Config->NetworkRate <= 0 )
00249 {
00250 RioErr << "ERROR: CheckConfiguration Invalid number of network "
00251 << "rate: " << Config->NetworkRate << endl;
00252 return ( 1 );
00253 }
00254
00255 if( Config->DiskThreads <= 0 )
00256 {
00257 RioErr << "ERROR: CheckConfiguration Invalid number of disk threads: "
00258 << Config->DiskThreads << endl;
00259 return ( 1 );
00260 }
00261
00262
00263
00264
00265
00266 if( Config->MaxLogFileSize <= 0 )
00267 {
00268 RioErr << "ERROR: CheckConfiguration Invalid maximum uncompacted log "
00269 << "size: " << Config->MaxLogFileSize << endl;
00270 return ( 1 );
00271 }
00272
00273 if( Config->MaxCombinedLogFilesSize <= 0 )
00274 {
00275 RioErr << "ERROR: CheckConfiguration Invalid total maximum combined "
00276 << "logs sizes: " << Config->MaxCombinedLogFilesSize << endl;
00277 return ( 1 );
00278 }
00279
00280
00281
00282 if( ( Config->SaveLogs != NULL ) &&
00283 ( strcasecmp( Config->SaveLogs, "on" ) != 0 ) &&
00284 ( strcasecmp( Config->SaveLogs, "off" ) != 0 ) )
00285 {
00286 RioErr << "ERROR: CheckConfiguration LogRotation value"
00287 << Config->SaveLogs << " invalid (must be 'on' or 'off')"
00288 << endl;
00289 return ( 1 );
00290 }
00291
00292
00293
00294 if( Config->ClientsTimeOut <= 0 )
00295 {
00296 RioErr << "ERROR: CheckConfiguration Invalid connection timeout: "
00297 << Config->ClientsTimeOut << endl;
00298 return ( 1 );
00299 }
00300
00301
00302 PrintConfiguration( Config );
00303
00304 return 0;
00305 }
00306
00307
00308
00309 int ReadConfiguration( char *ConfigsDirectory, StorageServerConfig *Config )
00310 {
00311
00312
00313 char ConfigFileName[ MaxPathSize ];
00314
00315
00316
00317 enum keys
00318 {
00319 Buffers = 1, CollectMeasures, EstimatedTime, SendBlocksFlag,
00320 MaxClientsCredits, MaxNetworkCredits, RouterPort,
00321 NetworkRate, DiskThreads, MaxLogFileSize, MaxCombinedLogFilesSize,
00322 LogRotation, ClientsTimeOut
00323 };
00324
00325 static struct token_kw mykeys[] = {
00326 {"Buffers", Buffers},
00327 {"CollectMeasures", CollectMeasures},
00328 {"EstimatedTime", EstimatedTime},
00329 {"SendBlocksFlag", SendBlocksFlag},
00330
00331
00332 {"MaxClientsCredits", MaxClientsCredits},
00333
00334
00335 {"MaxNetworkCredits", MaxNetworkCredits},
00336 {"RouterPort", RouterPort},
00337
00338 {"NetworkRate", NetworkRate},
00339 {"DiskThreads", DiskThreads},
00340
00341
00342
00343 {"MaxLogFileSize", MaxLogFileSize},
00344 {"MaxCombinedLogFilesSize", MaxCombinedLogFilesSize},
00345
00346
00347 {"LogRotation", LogRotation},
00348
00349
00350 {"ClientsTimeOut", ClientsTimeOut},
00351 {NULL, 0}
00352 };
00353
00354 cout << endl;
00355 token tok;
00356
00357
00358
00359
00360
00361
00362
00363 strcpy( ConfigFileName, ConfigsDirectory );
00364 strcat( ConfigFileName, CONFIGNAME );
00365
00366 if( tok.openfile( ConfigFileName ) )
00367 return 1;
00368
00369 int word;
00370 int number;
00371
00372 while( ( word = tok.parseline( mykeys )) != END_TOKEN )
00373 {
00374 switch( word )
00375 {
00376 case Buffers:
00377 tok.getnumber( &Config->Buffers );
00378 break;
00379
00380 case CollectMeasures:
00381 tok.getstrnew( &Config->CollectMeasures );
00382 break;
00383
00384 case EstimatedTime:
00385 tok.getdouble( &Config->EstimatedParameter );
00386 break;
00387
00388 case SendBlocksFlag:
00389 tok.getnumber( &Config->SendFlag );
00390 break;
00391
00392 case MaxClientsCredits:
00393 tok.getnumber( &Config->MaxClientsCredits );
00394 break;
00395
00396 case MaxNetworkCredits:
00397 tok.getnumber( &Config->MaxNetworkCredits );
00398 break;
00399
00400 case RouterPort:
00401 tok.getnumber( &Config->RouterPort );
00402 break;
00403
00404 case NetworkRate:
00405 tok.getnumber( &Config->NetworkRate );
00406 break;
00407
00408 case DiskThreads:
00409 tok.getnumber( &Config->DiskThreads );
00410 break;
00411
00412
00413
00414
00415 case MaxLogFileSize:
00416 tok.getnumber( &number );
00417
00418 Config->MaxLogFileSize = number * 1024;
00419 break;
00420
00421 case MaxCombinedLogFilesSize:
00422 tok.getnumber( &number );
00423
00424 Config->MaxCombinedLogFilesSize = ( ( unsigned long long int )
00425 number ) * 1024;
00426 break;
00427
00428
00429 case LogRotation:
00430 tok.getstrnew( &Config->SaveLogs );
00431 break;
00432
00433
00434 case ClientsTimeOut:
00435 tok.getnumber( &number );
00436 Config->ClientsTimeOut = ( unsigned int ) number;
00437 break;
00438
00439
00440 case ERROR_TOKEN:
00441 char *Aux;
00442 tok.getstrnew( &Aux );
00443 RioErr << "warning: invalid keyword " << Aux << " ignored!"
00444 << endl;
00445 delete[] Aux;
00446 break;
00447
00448
00449 default:
00450 RioErr << "word " << word << endl;
00451 tok.emsg("{default} invalid word");
00452 continue;
00453 }
00454 tok.ckend();
00455 }
00456 tok.closefile();
00457 return CheckConfiguration( Config );
00458 }
00459
00460 int main( int argc, char *argv[] )
00461 {
00462 unsigned int i;
00463 struct in_addr storageip;
00464 int port;
00465 char c;
00466 int stat;
00467 StorageServerConfig StorageConfig;
00468 int ind = -1;
00469
00470
00471
00472
00473
00474 static char opts_short[] = "hn:p:v";
00475 static struct option opts_int[] =
00476 {
00477 {"help" ,0,0,'h'},
00478 {"logsdirectory" ,1,0,'l'},
00479 {"ndisks" ,1,0,'n'},
00480
00481
00482
00483
00484 {"prefixdirectory" ,1,0,'p'},
00485 {"version" ,0,0,'v'},
00486 {0,0,0,0}
00487 };
00488
00489
00490 int nDisks = 1;
00491 bool CollectMeasures = false;
00492
00493 bool SaveLogs = true;
00494
00495 RioResult RioStatus;
00496
00497
00498 StorageConfig.Buffers = 0;
00499 StorageConfig.RouterPort = 5101;
00500 StorageConfig.SendFlag = 1;
00501 StorageConfig.DiskThreads = 1;
00502 StorageConfig.EstimatedParameter = 0;
00503 StorageConfig.CollectMeasures = NULL;
00504 StorageConfig.ClientsTimeOut = 18000;
00505
00506 StorageConfig.SaveLogs = NULL;
00507
00508
00509
00510
00511
00512 char *PrefixDirectory = NULL;
00513
00514 char *ConfigsDirectory = NULL;
00515
00516 char *LogsDirectory = NULL;
00517
00518 StorageConfig.NetworkRate = 100;
00519
00520
00521 StorageConfig.MaxNetworkCredits = 1;
00522
00523
00524 StorageConfig.MaxClientsCredits = 1;
00525
00526 StorageConfig.MaxLogFileSize = MAXLOGFILESIZE;
00527
00528 StorageConfig.MaxCombinedLogFilesSize = MAXCOMBINEDLOGSFILESIZE;
00529
00530
00531 RioErr << "MAINTHREADID " << syscall( SYS_gettid ) << endl;
00532
00533 char *ProgName = argv[ 0 ];
00534
00535 signal( SIGSEGV, segfaultHandler );
00536 signal( SIGTERM, signalHandler );
00537
00538 while( (c = getopt_long( argc, argv, opts_short, opts_int, &ind )) != -1 )
00539 {
00540 switch( c )
00541 {
00542 case 'n':
00543 nDisks = atoi(optarg);
00544 break;
00545 case 'h':
00546 usage(ProgName);
00547 return (0);
00548 case 'v':
00549 cout << "RIOStorage version: " << VERSION << endl;
00550 exit( 0 );
00551
00552
00553 case 'p':
00554 PrefixDirectory = optarg;
00555 break;
00556
00557
00558 default:
00559 usage( ProgName );
00560 return( 1 );
00561 }
00562 }
00563
00564 if( ( argc - optind ) < nDisks )
00565 {
00566 RioErr << "ERROR: Missing device names" << endl;
00567 usage( ProgName );
00568 return( 1 );
00569 }
00570
00571
00572
00573
00574 if( PrefixDirectory == NULL )
00575 {
00576
00577
00578
00579
00580 ConfigsDirectory = new char[ 1 ];
00581 if( ConfigsDirectory == NULL )
00582 {
00583 RioErr << "ERROR: Erro ao alocar a memoria" << endl;
00584 return ( 1 );
00585 }
00586 LogsDirectory = new char[ 1 ];
00587 if( LogsDirectory == NULL )
00588 {
00589 RioErr << "ERROR: Erro ao alocar a memoria" << endl;
00590 delete[] ConfigsDirectory;
00591 return ( 1 );
00592 }
00593 ConfigsDirectory[ 0 ] = 0;
00594 LogsDirectory[ 0 ] = 0;
00595 }
00596 else
00597 {
00598
00599
00600 unsigned int PrefixDirectorySize, ConfigsDirectorySize,
00601 LogsDirectorySize;
00602 PrefixDirectorySize = strlen( PrefixDirectory );
00603 ConfigsDirectorySize = PrefixDirectorySize + strlen( CONFIGSSUBDIR ) +
00604 1;
00605 LogsDirectorySize = PrefixDirectorySize + strlen( LOGSSUBDIR ) + 1;
00606
00607 if( PrefixDirectory[ PrefixDirectorySize - 1 ] != '/' )
00608 {
00609
00610
00611
00612 ConfigsDirectorySize++;
00613 LogsDirectorySize++;
00614 }
00615 ConfigsDirectory = new char[ ConfigsDirectorySize ];
00616 if( ConfigsDirectory == NULL )
00617 {
00618 RioErr << "ERROR: Erro ao alocar a memoria" << endl;
00619 return ( 1 );
00620 }
00621 LogsDirectory = new char[ LogsDirectorySize ];
00622 if( LogsDirectory == NULL )
00623 {
00624 RioErr << "ERROR: Erro ao alocar a memoria" << endl;
00625 delete[] ConfigsDirectory;
00626 return ( 1 );
00627 }
00628 strcpy( ConfigsDirectory, PrefixDirectory );
00629 strcpy( LogsDirectory, PrefixDirectory );
00630 if( PrefixDirectory[ PrefixDirectorySize - 1 ] != '/' )
00631 {
00632
00633
00634 strcat( ConfigsDirectory, "/" );
00635 strcat( LogsDirectory, "/" );
00636 }
00637 strcat( ConfigsDirectory, CONFIGSSUBDIR );
00638 strcat( LogsDirectory, LOGSSUBDIR );
00639 }
00640
00641 if( ( nDisks <= 0 ) || ( nDisks > MAXSTORAGEDISKSARRAY ) )
00642 {
00643 RioErr << "ERROR: Invalid number of disks: " << nDisks << endl;
00644 return(1);
00645 }
00646
00647
00648
00649 stat = ReadConfiguration( ConfigsDirectory, &StorageConfig );
00650
00651 if( stat )
00652 {
00653 RioErr << "ERROR: ReadConfiguration failed" << endl;
00654 RioErr << "Storage not running. Check error messages!" << endl;
00655 delete ConfigsDirectory;
00656 delete LogsDirectory;
00657 if( StorageConfig.CollectMeasures != NULL )
00658 delete StorageConfig.CollectMeasures;
00659 return (1);
00660 }
00661
00662
00663 if( StorageConfig.CollectMeasures != NULL )
00664 CollectMeasures = ( strcasecmp( StorageConfig.CollectMeasures, "on" )
00665 == 0 );
00666
00667
00668
00669 if( StorageConfig.SaveLogs != NULL )
00670 SaveLogs = ( strcasecmp( StorageConfig.SaveLogs, "on" ) == 0 );
00671
00672
00673
00674
00675
00676
00677
00678
00679
00680 delete ConfigsDirectory;
00681 if( StorageConfig.CollectMeasures != NULL )
00682 delete StorageConfig.CollectMeasures;
00683
00684 RioErr << "CollectMeasures: \t" << CollectMeasures << endl;
00685 RioErr << "EstimatedParameter: \t" << StorageConfig.EstimatedParameter
00686 << endl << endl;
00687
00688
00689 Config.nDisks = (u32) nDisks;
00690
00691 Config.BufferSize = (u32) StorageConfig.Buffers;
00692 Config.MaxReqSize = 1;
00693 Config.MaxReq = (u32) StorageConfig.Buffers;
00694 Config.RouterPort = (u16) StorageConfig.RouterPort;
00695 Config.Disk = new DiskConfig[Config.nDisks];
00696
00697
00698 for(i=0; i < Config.nDisks; i++)
00699 {
00700 Config.Disk[i].Name = argv[i+optind];
00701 }
00702
00703 Device = new CStorageDevice[Config.nDisks];
00704 if(Device == 0)
00705 {
00706 RioErr << "Error when creating device class: Not enough memory" << endl;
00707 return (1);
00708 }
00709
00710 RioErr << "Number of devices: "<< Config.nDisks << " (array created). "
00711 << endl;
00712
00713
00714
00715
00716
00717
00718 #ifdef RIO_DEBUG_FILE
00719
00720
00721 char tmpName[ MaxPathSize ];
00722 char tmpDomain[ MaxPathSize ];
00723 char LogFileName[ MaxPathSize ];
00724 strcpy( LogFileName, LogsDirectory );
00725
00726
00727 gethostname( tmpName, MaxPathSize - 1 );
00728
00729
00730 getdomainname( tmpDomain, MaxPathSize - 1 );
00731
00732
00733 strcat( LogFileName, "RIOStorageEmul_" );
00734 strcat( LogFileName, tmpName );
00735
00736
00737 if( strstr( tmpName, tmpDomain ) == NULL )
00738 {
00739 strcat( LogFileName, "." );
00740 strcat( LogFileName, tmpDomain );
00741 }
00742 strcat( LogFileName, ".log" );
00743
00744
00745 NetManager.Start( htons( STORAGESERVERUDPPORT ), 128 * 1024, FRAGMENTSIZE,
00746 LogFileName, StorageConfig.MaxClientsCredits,
00747 StorageConfig.MaxNetworkCredits,
00748 StorageConfig.NetworkRate );
00749
00750
00751
00752
00753
00754
00755
00756
00757
00758
00759
00760
00761
00762
00763
00764
00765 RioStatus = NetInterface.Start( htons( STORAGESERVERUDPPORT ),
00766 StorageConfig.ClientsTimeOut,
00767 NETTCPTIMEOUTSECONDS, NETTCPTIMEOUTSECONDS,
00768 NULL, true, LogFileName );
00769
00770 #else
00771
00772
00773 NetManager.Start( htons( STORAGESERVERUDPPORT ), 128 * 1024, FRAGMENTSIZE,
00774 StorageConfig.MaxClientsCredits,
00775 StorageConfig.MaxNetworkCredits,
00776 StorageConfig.NetworkRate );
00777
00778
00779
00780
00781
00782
00783
00784
00785
00786
00787
00788
00789
00790
00791
00792
00793 RioStatus = NetInterface.Start( htons( STORAGESERVERUDPPORT ),
00794 StorageConfig.ClientsTimeOut,
00795 NETTCPTIMEOUTSECONDS,
00796 NETTCPTIMEOUTSECONDS );
00797
00798 #endif
00799
00800
00801 if( FAILED( RioStatus ) )
00802 {
00803 #ifdef RIO_DEBUG2
00804 RioErr << "main: erro 0x" << hex << RioStatus << dec << " ("
00805 << GetErrorDescription( RioStatus ) << ") ao criar o objeto "
00806 << "da classe CNetIneface associado a nova conexao TCP."
00807 << endl;
00808 #endif
00809
00810 RioErr << "Error when initializing TCP" << endl;
00811 return (1);
00812 }
00813
00814
00815
00816
00817
00818
00819 NetInterface.getmyaddrport( (int*) &(storageip.s_addr), &port);
00820
00821
00822
00823
00824 char LogFileNamePrefix[ MaxPathSize ];
00825 strcpy( LogFileNamePrefix, LogsDirectory );
00826 strcat( LogFileNamePrefix, "StorageLog_" );
00827
00828
00829 strcat( LogFileNamePrefix, inet_ntoa( storageip ) );
00830 if( SentPackagesLog.Initialize( LogFileNamePrefix,
00831 StorageConfig.MaxLogFileSize,
00832 StorageConfig.MaxCombinedLogFilesSize,
00833 SaveLogs ) != S_OK )
00834 {
00835
00836 RioErr << "main: erro ao inicializar a classe com os logs." << endl;
00837 return (1);
00838 }
00839
00840
00841
00842 NetManager.setLogRotation( &SentPackagesLog );
00843
00844
00845 NetInterface.setLogRotation( &SentPackagesLog );
00846
00847
00848 for(i=0; i<Config.nDisks; i++)
00849 {
00850
00851
00852 stat = Device[i].Initialize(Config.Disk[i].Name,
00853 inet_ntoa( storageip ),
00854 StorageConfig.DiskThreads,
00855 StorageConfig.EstimatedParameter,
00856 CollectMeasures, LogsDirectory );
00857
00858 if(stat < 0)
00859 {
00860 RioErr << "Error when initializing Device " << Config.Disk[i].Name
00861 << ": " << stat << endl;
00862 return (1);
00863 }
00864 }
00865
00866
00867 for(i=0; i< Config.nDisks; i++)
00868 {
00869 Config.Disk[i].Size = Device[i].Size();
00870 Config.Disk[i].SectorSize = Device[i].SectorSize();
00871 }
00872
00873 stat = Client.Initialize( StorageConfig.SendFlag,
00874 StorageConfig.EstimatedParameter );
00875 if(stat < 0)
00876 {
00877 RioErr << "Error when initializing Client Interface: " << stat << endl;
00878 return (1);
00879 }
00880
00881 stat = MsgManager.Initialize( Config.MaxReq + 10 );
00882 if(stat < 0)
00883 {
00884 RioErr << "Error when initializing Msg Manager: " << stat << endl;
00885 return (1);
00886 }
00887
00888 RioErr << "Msg Manager started. Max number of msg : "<< Config.MaxReq + 10
00889 << " (array created). "<< endl;
00890
00891
00892
00893 stat = Router.Initialize( htons( Config.RouterPort ), LogsDirectory );
00894 if(stat < 0)
00895 {
00896 RioErr << "Error when initializing Router Interface: " << stat << endl;
00897 return (1);
00898 }
00899
00900
00901 RioErr << "TCP/IP address (control messages): "
00902 << inet_ntoa( storageip ) << ":"<< StorageConfig.RouterPort << endl;
00903
00904 if(!Finish.IsOpen())
00905 {
00906 RioErr << "ERROR: Semaphore could not be created" << endl;
00907 return (1);
00908 }
00909
00910
00911 Finish.P();
00912
00913 return (0);
00914 }