1 package com.daffodilwoods.daffodildb.server.datasystem.persistentsystem; 2 3 import java.util.*; 4 import java.io.*; 5 import com.daffodilwoods.database.resource.DException; 6 import com.daffodilwoods.database.general._MemoryHandler; 7 import com.daffodilwoods.daffodildb.server.datasystem.interfaces.*; 8 import com.daffodilwoods.database.utility.P; 9 import com.daffodilwoods.daffodildb.server.sql99.utils._Reference; 10 import com.daffodilwoods.daffodildb.server.datasystem.indexsystem.FixedBTreeCluster; 11 import com.daffodilwoods.daffodildb.server.serversystem.ServerSystem; 12 import java.util.RandomAccess ; 13 import com.daffodilwoods.daffodildb.server.datasystem.persistentsystem.versioninfo.VersionHandler; 14 import java.lang.ref.WeakReference ; 15 16 36 public class ClusterManager { 37 38 42 TableHashMap usedClusters; 43 44 48 49 private RandomAccessFile tempFile; 50 51 54 55 private PersistentDatabase database; 56 57 60 61 private TempFileHandler handler ; 62 63 66 67 private Vector freeAddresses; 68 69 73 DatabaseProperties databaseProperties; 74 75 78 VersionHandler versionHandler; 79 84 ClusterLock clusterLock; 85 86 public ClusterManager(RandomAccessFile tempFile0, PersistentDatabase database0,DatabaseProperties databaseProperties0,VersionHandler versionHandler0,String daffodilHome) { 87 versionHandler = versionHandler0; 88 clusterLock = new ClusterLock(); 89 databaseProperties = databaseProperties0; 90 tempFile = tempFile0; 91 handler = new TempFileHandler(this); 92 usedClusters = new TableHashMap(handler, database0.getDatabaseName(),databaseProperties); 93 freeAddresses = new Vector(); 94 database = database0; 95 96 } 97 107 108 118 119 120 121 final Cluster getClusterForWrite(_DatabaseUser user,ClusterCharacteristics cc ) throws DException{ 122 return getClusterForWrite(user,cc,false); 123 } 124 125 145 146 final Cluster getClusterForRead(ClusterCharacteristics cc ,boolean isBTreeCluster ) throws DException{ 147 KeyValue dbcl = (KeyValue)usedClusters.get(cc); 148 if(dbcl == null){ 149 clusterLock.lock(cc.getStartAddress()); 150 try{ 151 dbcl = (KeyValue) usedClusters.get(cc); 152 if (dbcl == null) { 153 Cluster cls = handler.getClusterFromClustersMap(cc); 154 if (cls == null) { 155 Cluster newCluster = isBTreeCluster ? 156 new FixedBTreeCluster(cc, databaseProperties, versionHandler) : 157 new Cluster(cc, databaseProperties, versionHandler); 158 dbcl = new KeyValue(newCluster, null); 159 long add = handler.getAddressOfTempFile(cc); 160 byte[] bytes = (add == -1) ? 161 database.getBytes(newCluster.clusterCharacteristics. 162 getStartAddress()) 163 : readFromTempFile(add); 164 newCluster.setBytesWithInitializeParameters(bytes); 165 if (add != -1) { 166 addInFreeAddressList(new Long (add)); 167 dbcl.setKey(""); 168 dbcl.cluster.setDirty(true); 169 } 170 } 171 else { 172 dbcl = new KeyValue(cls, cls.readMode ? null : ""); 173 long add = handler.getAddressOfTempFile(cc); 174 if (add != -1) { 175 addInFreeAddressList(new Long (add)); 176 } 177 } 178 } 179 usedClusters.updateClusterMappingForRead(cc, dbcl); 180 }finally{ 181 clusterLock.unLock(cc.getStartAddress()); 182 } 183 } 184 else{ 185 usedClusters.updateClusterMappingForRead(); 186 } 187 return dbcl.cluster; 188 } 189 210 211 212 final Cluster getClusterForWrite(_DatabaseUser user,ClusterCharacteristics cc,boolean isBTreeCluster ) throws DException{ 213 214 KeyValue dbcl = (KeyValue)usedClusters.get(cc); 215 if(dbcl == null){ 216 clusterLock.lock(cc.getStartAddress()); 217 try { 218 dbcl = (KeyValue) usedClusters.get(cc); 219 if (dbcl == null) { 220 Cluster cls = handler.getClusterFromClustersMap(cc); 221 if (cls == null) { 222 cls = isBTreeCluster ? 223 new FixedBTreeCluster(cc, databaseProperties, versionHandler) : 224 new Cluster(cc, databaseProperties, versionHandler); 225 long add = handler.getAddressOfTempFile(cc); 226 byte[] bytes = (add == -1) ? 227 database.getBytes(cls.clusterCharacteristics.getStartAddress()) 228 : readFromTempFile(add); 229 cls.setBytesWithInitializeParameters(bytes); 230 if (add != -1) { 231 addInFreeAddressList(new Long (add)); 232 cls.setDirty(true); 233 } 234 } 235 else { 236 long add = handler.getAddressOfTempFile(cc); 237 if (add != -1) { 238 addInFreeAddressList(new Long (add)); 239 } 240 241 } 242 243 dbcl = new KeyValue(cls, ""); 244 usedClusters.updateClusterMappingForRead(cc, dbcl); 245 } 246 else { 247 dbcl.setKey(""); 248 usedClusters.updateClusterMappingForRead(cc, dbcl); 249 } 250 251 }finally{ 252 clusterLock.unLock(cc.getStartAddress()); 253 } 254 } 255 else{ 256 dbcl.setKey(""); 257 usedClusters.updateClusterMappingForRead(); 258 } 259 Cluster cluster = dbcl.cluster; 260 user.addCluster(cluster); 261 return cluster; 262 } 263 264 267 268 269 272 273 private byte[] readFromTempFile(long address) throws DException{ 274 try{ 275 byte[] bytes = new byte[databaseProperties.CLUSTERSIZE]; 276 synchronized(tempFile){ 277 tempFile.seek(address); 278 tempFile.read(bytes); 279 } 280 return bytes; 281 } 282 catch(IOException ioe) { 283 throw new DException("DSE2025",new Object [] {ioe.getMessage()}); 284 } 285 } 286 287 291 292 void writeInTempFile(Cluster cluster,byte[] bytes) throws DException{ 293 synchronized(tempFile){ 294 try { 295 long address = tempFile.length(); 296 int size = freeAddresses.size(); 297 if(size > 0){ 298 address = ((Long )freeAddresses.get(size - 1)).longValue(); 299 tempFile.seek(address); 300 tempFile.write(bytes); 301 freeAddresses.remove(size-1); 302 size--; 303 } 304 else{ 305 tempFile.seek(address); 306 tempFile.write(bytes); 307 } 308 handler.addAddressOfTempFile(cluster.clusterCharacteristics,address); 309 handler.addCluster(cluster); 310 } 311 catch (IOException ex) { 312 throw new DException("DSE2025",new Object [] {ex.getMessage()}); 313 } 314 } 315 } 316 326 void updateWriteClusters(Cluster cluster) throws DException{ 327 if(usedClusters.size() > databaseProperties.CLUSTERS_IN_MEMORY_FOR_WRITE){ 328 usedClusters.updateClusterMappingForReadWrite(); 329 330 if(usedClusters.size() > databaseProperties.CLUSTERS_IN_MEMORY_FOR_WRITE){ 331 writeInTempFile(cluster, cluster.getBytes()); 332 removeCluster(cluster.getClusterCharacteristics()); 333 } 334 } 335 } 336 337 final void addInFreeAddressList(Long ll) throws DException{ 338 if(!freeAddresses.contains(ll)){ 339 freeAddresses.add(ll); 340 } 341 } 342 350 final Cluster getNewClusterForWrite(_DatabaseUser user,ClusterCharacteristics cc,boolean flag ) throws DException{ 351 clusterLock.lock(cc.getStartAddress()); 352 try{ 353 Cluster cls = flag ? 354 new FixedBTreeCluster(cc, databaseProperties, versionHandler) : 355 new Cluster(cc, databaseProperties, versionHandler); 356 byte[] bytes = new byte[databaseProperties.CLUSTERSIZE]; 357 Arrays.fill(bytes, (byte) 0); 358 cls.setBytes(bytes); 359 cls.setDirty(true); 360 KeyValue dbcl = new KeyValue(cls, ""); 361 usedClusters.updateClusterMappingForRead(cc, dbcl); 362 Cluster cluster = dbcl.cluster; 363 user.addCluster(cluster); 364 return cluster; 365 }finally{ 366 clusterLock.unLock(cc.getStartAddress()); 367 } 368 369 } 370 371 379 380 final Cluster getStartClusterForWriteFirst(_DatabaseUser user,ClusterCharacteristics cc,boolean flag ) throws DException{ 381 382 KeyValue dbcl = (KeyValue)usedClusters.get(cc); 383 if(dbcl == null){ 384 clusterLock.lock(cc.getStartAddress()); 385 try{ 386 dbcl = (KeyValue) usedClusters.get(cc); 387 if (dbcl == null) { 388 Cluster cls = handler.getClusterFromClustersMap(cc); 389 if (cls == null) { 390 cls = flag ? new FixedBTreeCluster(cc, databaseProperties,versionHandler) : 391 new Cluster(cc, databaseProperties,versionHandler); 392 long add = handler.getAddressOfTempFile(cc); 393 byte[] bytes = (add == -1) ? 394 database.getBytesFirst(cls.clusterCharacteristics. 395 getStartAddress()) 396 : readFromTempFile(add); 397 cls.setBytes(bytes); 398 if (add != -1) { 399 addInFreeAddressList(new Long (add)); 400 cls.setDirty(true); 401 } 402 }else{ 403 long add = handler.getAddressOfTempFile(cc); 404 if (add != -1){ 405 addInFreeAddressList(new Long (add)); 406 } 407 408 } 409 410 dbcl = new KeyValue(cls, ""); 411 usedClusters.updateClusterMappingForRead(cc, dbcl); 412 } 413 else{ 414 dbcl.setKey(""); 415 usedClusters.updateClusterMappingForRead(cc,dbcl); 416 } 417 418 }finally{ 419 clusterLock.unLock(cc.getStartAddress()); 420 } 421 } 422 else{ 423 dbcl.setKey(""); 424 usedClusters.updateClusterMappingForRead(); 425 } 426 Cluster cluster = dbcl.cluster; 427 user.addCluster(cluster); 428 return cluster; 429 } 430 431 437 final Cluster getClusterForReadFirst(ClusterCharacteristics cc ) throws DException{ 438 439 KeyValue dbcl = (KeyValue)usedClusters.get(cc); 440 if(dbcl == null){ 441 clusterLock.lock(cc.getStartAddress()); 442 try{ 443 dbcl = (KeyValue)usedClusters.get(cc); 444 if( dbcl == null ){ 445 Cluster cls = handler.getClusterFromClustersMap(cc); 446 if(cls == null){ 447 Cluster newCluster = new Cluster(cc,databaseProperties,versionHandler); 448 dbcl = new KeyValue(newCluster, null); 449 long add = handler.getAddressOfTempFile(cc); 450 byte[] bytes = (add == -1) ? database.getBytesFirst(newCluster.clusterCharacteristics.getStartAddress()) 451 : readFromTempFile(add); 452 newCluster.setBytesWithInitializeParameters(bytes); 453 if(add != -1 ){ 454 addInFreeAddressList(new Long (add)); 455 dbcl.setKey(""); 456 } 457 } 458 else{ 459 dbcl = new KeyValue(cls, cls.readMode ? null : ""); 460 long add = handler.getAddressOfTempFile(cc); 461 if (add != -1) 462 addInFreeAddressList(new Long (add)); 463 464 } 465 } 466 usedClusters.updateClusterMappingForRead(cc,dbcl); 467 468 } finally{ 469 clusterLock.unLock(cc.getStartAddress()); 470 } 471 } 472 else 473 usedClusters.updateClusterMappingForRead(); 474 return dbcl.cluster; 475 } 476 481 void closeFile()throws IOException{ 482 if(tempFile!= null) 483 tempFile.close(); 484 } 485 490 public void removeCluster(ClusterCharacteristics cc) throws DException { 491 clusterLock.lock(cc.getStartAddress()); 492 try{ 493 synchronized (usedClusters) { 494 usedClusters.remove(cc); 495 } 496 }finally{ 497 clusterLock.unLock(cc.getStartAddress()); 498 } 499 } 500 509 final Cluster getClusterForPowerFile(ClusterCharacteristics cc ,boolean isBTreeCluster ) throws DException{ 510 KeyValue dbcl = (KeyValue)usedClusters.get(cc); 511 if(dbcl == null){ 512 clusterLock.lock(cc.getStartAddress()); 513 try{ 514 dbcl = (KeyValue)usedClusters.get(cc); 515 if( dbcl == null ){ 516 Cluster cls = handler.getClusterFromClustersMap(cc); 517 if(cls == null){ 518 Cluster newCluster = isBTreeCluster ? new FixedBTreeCluster(cc,databaseProperties,versionHandler): new Cluster(cc,databaseProperties,versionHandler); 519 dbcl = new KeyValue(newCluster, null); 520 long add = handler.getAddressOfTempFileForPowerFile(cc); 521 byte[] bytes = (add == -1) ? database.getBytes(newCluster.clusterCharacteristics.getStartAddress()) 522 : readFromTempFile(add); 523 newCluster.setBytesWithInitializeParameters(bytes); 524 if(add != -1 ){ 525 dbcl.setKey(""); 526 dbcl.cluster.setDirty(true); 527 } 528 } 529 else{ 530 dbcl = new KeyValue(cls, cls.readMode ? null : ""); 531 } 532 } 533 usedClusters.updateClusterMappingForRead(); 534 535 }finally{ 536 clusterLock.unLock(cc.getStartAddress()); 537 } 538 } 539 else 540 usedClusters.updateClusterMappingForRead(); 541 return dbcl.cluster; 542 } 543 544 547 548 boolean checkInMap(ClusterCharacteristics cc) { 549 return usedClusters.get(cc) != null; 550 } 551 555 public RandomAccessFile getTempFile() { 556 return tempFile; 557 } 558 562 public Vector getFreeAddresses(){ 563 return freeAddresses; 564 } 565 573 public void removeClusterBeforeAddingInFreeList(ClusterCharacteristics cc) throws DException{ 574 clusterLock.lock(cc.getStartAddress()); 575 try{ 576 synchronized (usedClusters) { 577 usedClusters.remove(cc); 578 } 579 Cluster cls = handler.getClusterFromClustersMap(cc); 580 584 long add = handler.getAddressOfTempFile(cc); 585 if(add != -1 ) 586 addInFreeAddressList(new Long (add)); 587 }finally{ 588 clusterLock.unLock(cc.getStartAddress()); 589 } 590 } 591 } 592 | Popular Tags |