~smaioli/azureus/ubuntu-experimental : revision 24

org/gudy/azureus2/core3/util/AEDiagnostics.java

if ( TRACE_TCP_TRANSPORT_STATS ){

System.out.println( "**** TCP_TRANSPORT_STATS tracing on ****" );

}

int maxFileSize = 256 * 1024;

try {

String logSize = System.getProperty("diag.logsize", null);

if (logSize != null) {

if (logSize.toLowerCase().endsWith("m")) {

maxFileSize = Integer.parseInt(logSize.substring(0,

logSize.length() - 1)) * 1024 * 1024;

} else {

maxFileSize = Integer.parseInt(logSize);

}

100

} catch (Throwable t) {

101

}

102

MAX_FILE_SIZE = maxFileSize;

103

}

104

private static final int MAX_FILE_SIZE = 256*1024; // get two of these per logger type

105

private static final int MAX_FILE_SIZE; // get two of these per logger type

106

107

private static final String CONFIG_KEY = "diagnostics.tidy_close";

108

112

113

private static boolean started_up;

114

private static boolean startup_complete;

100

101

private static Map loggers = new HashMap();

102

private static boolean loggers_enabled;

115

private static boolean enable_pending_writes;

116

117

private static Map<String,AEDiagnosticsLogger> loggers = new HashMap<String, AEDiagnosticsLogger>();

118

119

protected static boolean loggers_enabled;

103

120

104

121

private static List evidence_generators = new ArrayList();

105

122

106

123

private static boolean load_15_tried;

107

124

108

125

public static synchronized void

109

startup()

126

startup(

127

boolean _enable_pending )

110

128

{

111

129

if ( started_up ){

112

130

115

133

116

134

started_up = true;

117

135

136

enable_pending_writes = _enable_pending;

137

118

138

try{

119

139

// Minimize risk of loading to much when in transitory startup mode

120

140

boolean transitoryStartup = System.getProperty("transitory.startup", "0").equals("1");

285

305

public static File

286

306

getLogDir()

287

307

{

288

startup();

308

startup( false );

289

309

290

310

return( debug_dir );

291

311

}

292

312

313

public static synchronized void

314

flushPendingLogs()

315

{

316

for ( AEDiagnosticsLogger logger: loggers.values()){

317

318

logger.writePending();

319

}

320

321

enable_pending_writes = false;

322

}

323

293

324

public static synchronized AEDiagnosticsLogger

294

325

getLogger(

295

326

String name )

298

329

299

330

if ( logger == null ){

300

331

301

startup();

302

303

logger = new AEDiagnosticsLogger( name );

304

305

try{

306

File f1 = getLogFile( logger );

307

308

logger.setFirstFile( false );

309

310

File f2 = getLogFile( logger );

311

312

logger.setFirstFile( true );

313

314

// if we were writing to the second file, carry on from there

315

316

if ( f1.exists() && f2.exists()){

317

318

if ( f1.lastModified() < f2.lastModified()){

319

320

logger.setFirstFile( false );

321

}

322

}

323

}catch( Throwable ignore ){

324

325

}

332

startup( false );

333

334

logger = new AEDiagnosticsLogger( debug_dir, name, MAX_FILE_SIZE, !enable_pending_writes );

326

335

327

336

loggers.put( name, logger );

328

329

337

}

330

338

331

339

return( logger );

347

355

getLogger( logger_name ).log( str );

348

356

}

349

357

350

protected static synchronized void

351

log(

352

AEDiagnosticsLogger logger,

353

String str )

354

{

355

if ( !loggers_enabled ){

356

357

return;

358

}

359

360

try{

361

362

File log_file = getLogFile( logger );

363

364

/**

365

* log_file.length will return 0 if the file doesn't exist, so we don't need

366

* to explicitly check for its existence.

367

368

if ( log_file.length() >= MAX_FILE_SIZE ){

369

370

logger.setFirstFile(!logger.isFirstFile());

371

372

log_file = getLogFile( logger );

373

374

// If the file doesn't exist, this will just return false.

375

log_file.delete();

376

}

377

378

Calendar now = GregorianCalendar.getInstance();

379

380

String timeStamp =

381

"[" + format(now.get(Calendar.DAY_OF_MONTH))+format(now.get(Calendar.MONTH)+1) + " " +

382

format(now.get(Calendar.HOUR_OF_DAY))+ ":" + format(now.get(Calendar.MINUTE)) + ":" + format(now.get(Calendar.SECOND)) + "] ";

383

384

str = timeStamp + str;

385

386

PrintWriter pw = null;

387

388

try{

389

390

pw = new PrintWriter(new FileWriter( log_file, true ));

391

392

if (!logger.isWrittenToThisSession()) {

393

logger.setWrittenToThisSession(true);

394

pw.println("\n\n[" + now.get(Calendar.YEAR)

395

+ "] Log File Opened for " + Constants.APP_NAME + " "

396

+ Constants.AZUREUS_VERSION + "\n");

397

}

398

399

pw.println( str );

400

401

}finally{

402

403

if ( pw != null ){

404

405

pw.close();

406

}

407

}

408

}catch( Throwable ignore ){

409

410

}

411

}

412

413

private static File

414

getLogFile(

415

AEDiagnosticsLogger logger )

416

{

417

return( new File( debug_dir, logger.getName() + "_" + (logger.isFirstFile()?"1":"2") + ".log" ));

418

}

419

420

private static String

421

format(

422

int n )

423

{

424

if (n < 10){

425

426

return( "0" + n );

427

}

428

429

return( String.valueOf(n));

430

}

431

432

protected static void

433

log(

434

AEDiagnosticsLogger logger,

435

Throwable e )

436

{

437

try{

438

ByteArrayOutputStream baos = new ByteArrayOutputStream();

439

440

PrintWriter pw = new PrintWriter( new OutputStreamWriter( baos ));

441

442

e.printStackTrace( pw );

443

444

pw.close();

445

446

log( logger, baos.toString());

447

448

}catch( Throwable ignore ){

449

450

}

451

}

452

453

358

public static void

454

359

markDirty()

455

360

{

Older »