Exemple #1
1
  public String getTextForGesture(long parId, Point topLeft, Point bottomRight) {

    try {
      Paragraph p = lockManager.getParFromId(parId);

      int parY = documentPanel.textPane.modelToView(p.getOffset()).y;

      topLeft.y = topLeft.y + parY;
      bottomRight.y = bottomRight.y + parY;

      int startOffset = documentPanel.textPane.viewToModel(topLeft);
      int endOffset = documentPanel.textPane.viewToModel(bottomRight);

      while (startOffset > 0
          && Character.isLetterOrDigit((document.getText(startOffset - 1, 1).charAt(0))))
        startOffset--;

      while (endOffset < document.getLength()
          && Character.isLetterOrDigit((document.getText(endOffset, 1).charAt(0)))) endOffset++;

      String text = document.getText(startOffset, endOffset - startOffset);
      return text;
    } catch (Exception e) {
      System.out.println("EditorClient: addGestureAction. error identifying text");
      e.printStackTrace();
      return "";
    }

    // return "PLACEBO";
  }
Exemple #2
0
  public long getParIdForGesture(long startParId, int y) {
    Paragraph startPar = lockManager.getParFromId(startParId);
    int startParY = documentPanel.getYValueFromOffset(startPar.getOffset());

    int offset = documentPanel.getOffsetFromPoint(new Point(25, startParY + y));
    return lockManager.getParFromOffset(offset).getID();
  }
Exemple #3
0
  public void sendHighlights() {

    // send highlights to everybody
    try {
      Iterator i = highlights.getHighlights().iterator();
      while (i.hasNext()) {
        Highlights.Highlight h = (Highlights.Highlight) i.next();
        Paragraph sPar = lockManager.getParFromOffset(h.getStart());
        Paragraph ePar = lockManager.getParFromOffset(h.getEnd());

        if (EditorServer_Debug) {
          System.out.println("StartPar: " + sPar.toString());
          System.out.println("EndPar: " + ePar.toString());
        }

        Message.HighlightAddMsg msg =
            new Message.HighlightAddMsg(
                -1,
                h.getId(),
                h.getType().getId(),
                sPar.getID(),
                ePar.getID(),
                h.getStart() - sPar.getOffset(),
                h.getEnd() - ePar.getOffset());
        textChannel.sendToOthers(client, new Data(msg));
      }
    } catch (Exception e) {
      System.err.println("EditorServer: sendHighlights: error sending msg");
      if (EditorServer_Debug) e.printStackTrace();
    }
  }
Exemple #4
0
 /** ロック開放後同一カテゴリとキーでロック取得可能. */
 @Test
 public void ロック開放後同一カテゴリとキーでロック取得可能() {
   Lock lock = LockManager.getLock(Lock.CATEGORY_ODATA, "aaa", null, null);
   lock.release();
   Lock lock2 = LockManager.getLock(Lock.CATEGORY_ODATA, "aaa", null, null);
   assertNotNull(lock2);
   lock2.release();
 }
Exemple #5
0
 /** 違うカテゴリであれば同キー名での連続取得が可能. */
 @Test
 public void 違うカテゴリであれば同キー名での連続取得が可能() {
   Lock lockOData = LockManager.getLock(Lock.CATEGORY_ODATA, "aaa", null, null);
   Lock lockDav = LockManager.getLock(Lock.CATEGORY_DAV, "aaa", null, null);
   assertNotNull(lockOData);
   assertNotNull(lockDav);
   lockDav.release();
   lockOData.release();
 }
Exemple #6
0
 /**
  * Commit or abort a given transaction; release all locks associated to the transaction.
  *
  * @param tid the ID of the transaction requesting the unlock
  * @param commit a flag indicating whether we should commit or abort
  */
 public void transactionComplete(TransactionId tid, boolean commit) throws IOException {
   if (commit) {
     Set<PageId> dirtiedFlushedPages = transactionsToDirtiedFlushedPages.get(tid);
     for (PageId pageId : pageIdToPages.keySet()) {
       Page page = pageIdToPages.get(pageId);
       if (tid.equals(page.isDirty())) {
         flushPage(pageId);
         // use current page contents as the before-image
         // for the next transaction that modifies this page.
         page.setBeforeImage();
       } else if (dirtiedFlushedPages != null && dirtiedFlushedPages.contains(pageId)) {
         page.setBeforeImage();
       }
     }
   } else {
     for (PageId pageId : pageIdToPages.keySet()) {
       Page page = pageIdToPages.get(pageId);
       if (tid.equals(page.isDirty())) {
         pageIdToPages.put(pageId, page.getBeforeImage());
         page.markDirty(false, null);
       }
     }
   }
   transactionsToDirtiedFlushedPages.remove(tid);
   lockManager.releasePages(tid);
   // if commit, flush dirty pages associated with transaction
   // if !commit, restore dirty pages associated with transaction to
   // previous
   // state
   // release all locks (and other state? don't think there is any)
 }
Exemple #7
0
  @Override
  protected void configure() throws JournalException {
    writeLock = LockManager.lockExclusive(getLocation());
    if (writeLock == null || !writeLock.isValid()) {
      close();
      throw new JournalException("Journal is already open for APPEND at %s", getLocation());
    }
    if (txLog.isEmpty()) {
      commit(Tx.TX_NORMAL, 0L, 0L);
    }
    txLog.head(tx);

    File meta = new File(getLocation(), JournalConfiguration.FILE_NAME);
    if (!meta.exists()) {
      try (UnstructuredFile hb = new UnstructuredFile(meta, 12, JournalMode.APPEND)) {
        getMetadata().write(hb);
      }
    }

    super.configure();

    beginTx();
    rollback();
    rollbackPartitionDirs();

    if (tx.journalMaxRowID > 0
        && getPartitionCount() <= Rows.toPartitionIndex(tx.journalMaxRowID)) {
      beginTx();
      commit();
    }
    if (getMetadata().getLag() != -1) {
      this.partitionCleaner = new PartitionCleaner(this, getLocation().getName());
      this.partitionCleaner.start();
    }
  }
Exemple #8
0
 /**
  * Retryが指定回数行われる.
  *
  * @throws InterruptedException InterruptedException
  */
 @Test
 @Ignore
 public void Retryが指定回数行われる() throws InterruptedException {
   LockManager originalLm = LockManager.singleton;
   LockManager.singleton = new RetryCountingLockManager();
   RetryCountingLockManager rclm = (RetryCountingLockManager) LockManager.singleton;
   try {
     LockManager.getLock(Lock.CATEGORY_ODATA, "aaa", null, null);
   } catch (DcCoreException e) {
     assertEquals(DcCoreException.class, e.getClass());
   } finally {
     // doGetLock呼び出し回数 は 最初の呼び出しの1回と + リトライ回数 となる
     assertEquals(LockManager.getLockRetryTimes() + 1, rclm.getCount);
     LockManager.singleton = originalLm;
   }
 }
Exemple #9
0
  @Override
  public final void close() {
    if (open) {
      if (partitionCleaner != null) {
        partitionCleaner.halt();
        partitionCleaner = null;
      }
      try {
        if (isCommitOnClose()) {
          commit();
          purgeUnusedTempPartitions(txLog);
        }
        super.close();
        if (writeLock != null) {
          LockManager.release(writeLock);
          writeLock = null;
        }

        if (discardTxtRaf != null) {
          try {
            discardSink.close();
            discardTxtRaf.close();
          } catch (IOException e) {
            LOGGER.warn("Failed to close discard file");
          }
        }
      } catch (JournalException e) {
        throw new JournalRuntimeException(e);
      }
    }
  }
Exemple #10
0
  public void textInserted(Message.TextInsertMsg m) {
    if (EditorServer_Debug) System.err.println("EditorServer-> textInserted.");

    try {
      int ClientId = m.getClientId();
      int offset = m.getOffset();
      String characterInserted = m.getText();

      if (EditorServer_Debug)
        System.out.println("EditorServer-> textInserted : *" + characterInserted + "*");

      Vector pars = lockManager.textInserted(m.getPar(), offset, characterInserted, ClientId);

      textChannel.sendToOthers(client, new Data(m));
      EditorClient c = getEditorClient(ClientId);

      // new condition inserted to avoid timestamp generation if the character
      // is a newline

      if (characterInserted.equals("\n")) {
        if (EditorServer_Debug)
          System.out.println("EditorServer-> textInserted : attempting to insert a newLine");
      }
      c.addTextInsertAction(System.currentTimeMillis(), pars, offset, characterInserted);
      clientsPanel.updateActionTableFor(c);
      updateParagraphList();

    } catch (Exception e) {
      System.err.println("EditorServer-> textInserted: error receiving-sending msg");
      if (EditorServer_Debug) e.printStackTrace();
    }
  }
Exemple #11
0
  public void textInserted(Message.TextPasteMsg m) {

    try {

      int SenderId = m.getClientId();
      int offset = m.getOffset();
      String textPasted = m.getText();

      if (EditorServer_Debug)
        System.err.println("EditorServer->textinserted : PASTED by : " + SenderId);

      Vector pars = null;
      try {
        pars = lockManager.textInserted(m.getPar(), offset, textPasted, SenderId);
        if (EditorServer_Debug)
          System.err.println("\n+=*%EditorServer--> textInserted recovered VECTOR...");
      } catch (Exception e) {
        System.err.println("\n+=*%EditorServer--> textInserted VECTOR error ");
      }

      textChannel.sendToOthers(client, new Data(m));

      EditorClient SenderClient = getEditorClient(SenderId);
      SenderClient.addTextPasteAction(System.currentTimeMillis(), pars, offset, textPasted);
      clientsPanel.updateActionTableFor(SenderClient);
      updateParagraphList();
    } catch (Exception e) {
      System.err.println("\nEditorServer--> textPasted: error sending msg");
      if (EditorServer_Debug) e.printStackTrace();
    }
  }
Exemple #12
0
 /**
  * Creates a BufferPool that caches up to numPages pages.
  *
  * @param numPages maximum number of pages in this buffer pool.
  */
 public BufferPool(int numPages) {
   this.maxPages = numPages;
   this.pageIdToPages = new HashMap<PageId, Page>();
   this.transactionsToDirtiedFlushedPages = new HashMap<TransactionId, Set<PageId>>();
   this.lockManager = LockManager.create();
   currentPages = new AtomicInteger(0);
 }
Exemple #13
0
  public void purgeUnusedTempPartitions(TxLog txLog) throws JournalException {
    final Tx tx = new Tx();
    final String lagPartitionName =
        hasIrregularPartition() ? getIrregularPartition().getName() : null;

    File[] files =
        getLocation()
            .listFiles(
                new FileFilter() {
                  public boolean accept(File f) {
                    return f.isDirectory()
                        && f.getName().startsWith(Constants.TEMP_DIRECTORY_PREFIX)
                        && (lagPartitionName == null || !lagPartitionName.equals(f.getName()));
                  }
                });

    if (files != null) {

      Arrays.sort(files);

      for (int i = 0; i < files.length; i++) {

        if (!txLog.isEmpty()) {
          txLog.head(tx);
          if (files[i].getName().equals(tx.lagName)) {
            continue;
          }
        }

        // get exclusive lock
        Lock lock = LockManager.lockExclusive(files[i]);
        try {
          if (lock != null && lock.isValid()) {
            LOGGER.trace("Purging : %s", files[i]);
            if (!Files.delete(files[i])) {
              LOGGER.info("Could not purge: %s", files[i]);
            }
          } else {
            LOGGER.trace("Partition in use: %s", files[i]);
          }
        } finally {
          LockManager.release(lock);
        }
      }
    }
  }
Exemple #14
0
 /** 同じキー名での取得は2回目以降のものはブロックされる. */
 @Test
 public void 同じキー名での取得は2回目以降のものはブロックされる() {
   Lock lock = null;
   Lock lock2 = null;
   String lockName = "lk" + new Date().getTime();
   try {
     lock = LockManager.getLock(Lock.CATEGORY_ODATA, lockName, null, null);
     lock2 = LockManager.getLock(Lock.CATEGORY_ODATA, lockName, null, null);
   } catch (DcCoreException e) {
     assertEquals(DcCoreException.class, e.getClass());
   } finally {
     lock.release();
     if (lock2 != null) {
       lock2.release();
     }
   }
 }
  public V get(K key) {
    V v = cache.getIfPresent(key);
    if (v == null) {
      try {
        lockManager.hold(locks, key);
        if (v == null) {
          v = loader.load(key);
          cache.put(key, v);
        }
      } catch (Exception ex) {
        PGException.pgThrow(ex);
      } finally {
        lockManager.release(locks, key);
      }
    }

    return v;
  }
Exemple #16
0
 public void sendDocumentState(int clientId) {
   Message.DocumentStateMsg msg =
       new Message.DocumentStateMsg(clientId, lockManager.getDocumentAsXML());
   try {
     clientChannel.sendToOthers(client, new Data(msg));
   } catch (Exception e) {
     System.err.println("EditorServer: sendDocumentState: error sending msg");
     if (EditorServer_Debug) e.printStackTrace();
   }
 }
Exemple #17
0
  public void lockReleased(Message.LockReleaseMsg m) {
    if (EditorServer_Debug) System.err.println("EditorServer: lockReleased.");

    lockManager.lockReleased(m.getStartPar(), m.getEndPar(), m.getClientId());
    try {
      textChannel.sendToOthers(client, new Data(m));
    } catch (Exception e) {
      System.err.println("EditorServer: lockReleased: error sending lock released");
      if (EditorServer_Debug) e.printStackTrace();
    }
  }
 /**
  * Check access on the new superior entry if it exists. If the entry does not exist or the DN
  * cannot be locked then false is returned.
  *
  * @param superiorDN The DN of the new superior entry.
  * @param op The modifyDN operation to check access on.
  * @return True if access is granted to the new superior entry.
  * @throws DirectoryException If a problem occurs while trying to retrieve the new superior entry.
  */
 private boolean aciCheckSuperiorEntry(DN superiorDN, LocalBackendModifyDNOperation op)
     throws DirectoryException {
   boolean ret = false;
   final Lock entryLock = LockManager.lockRead(superiorDN);
   if (entryLock == null) {
     Message message =
         WARN_ACI_HANDLER_CANNOT_LOCK_NEW_SUPERIOR_USER.get(String.valueOf(superiorDN));
     logError(message);
     return false;
   }
   try {
     Entry superiorEntry = DirectoryServer.getEntry(superiorDN);
     if (superiorEntry != null) {
       AciLDAPOperationContainer operationContainer =
           new AciLDAPOperationContainer(op, (ACI_IMPORT), superiorEntry);
       ret = accessAllowed(operationContainer);
     }
   } finally {
     LockManager.unlock(superiorDN, entryLock);
   }
   return ret;
 }
Exemple #19
0
  public void textDeleted(Message.TextCutMsg m) {
    if (EditorServer_Debug) System.err.println("EditorServer ->textCut.");

    try {

      long StartPar = m.getStartPar();
      long EndPar = m.getEndPar();
      int StartOffset = m.getStartOffset();
      int EndOffset = m.getEndOffset();

      String text = lockManager.getText(StartPar, StartOffset, EndPar, EndOffset);
      Vector pars = lockManager.textDeleted(StartPar, StartOffset, EndPar, EndOffset);
      textChannel.sendToOthers(client, new Data(m));
      EditorClient c = getEditorClient(m.getClientId());
      c.addTextCutAction(System.currentTimeMillis(), pars, StartOffset, EndOffset, text);
      clientsPanel.updateActionTableFor(c);
      updateParagraphList();
    } catch (Exception e) {
      System.err.println("EditorServer---> textDeleted(cut): error sending msg");
      if (EditorServer_Debug) e.printStackTrace();
    }
  }
Exemple #20
0
 /**
  * Retrieve the specified page with the associated permissions. Will acquire a lock and may block
  * if that lock is held by another transaction.
  *
  * <p>The retrieved page should be looked up in the buffer pool. If it is present, it should be
  * returned. If it is not present, it should be added to the buffer pool and returned. If there is
  * insufficient space in the buffer pool, an page should be evicted and the new page should be
  * added in its place.
  *
  * @param tid the ID of the transaction requesting the page
  * @param pid the ID of the requested page
  * @param perm the requested permissions on the page
  * @throws DbException
  * @throws TransactionAbortedException
  */
 public Page getPage(TransactionId tid, PageId pid, Permissions perm)
     throws DbException, TransactionAbortedException {
   lockManager.acquireLock(tid, pid, perm);
   if (pageIdToPages.containsKey(pid)) {
     return pageIdToPages.get(pid);
   }
   if (currentPages.get() == maxPages) {
     evictPage();
   }
   int tableId = pid.getTableId();
   Catalog catalog = Database.getCatalog();
   DbFile dbFile = catalog.getDatabaseFile(tableId);
   Page page = dbFile.readPage(pid);
   pageIdToPages.put(pid, page);
   currentPages.incrementAndGet();
   return page;
 }
Exemple #21
0
  public void lockRequested(Message.LockRequestMsg m) {
    if (EditorServer_Debug) System.err.println("EditorServer -> lockRequested.");

    /*
      java.util.Timer t = new java.util.Timer() ;
      t.schedule(new TimerTask() {
      public void run() {
      client.lockDenied(id) ;
      }
      }, 3000) ;
    */

    if (lockManager.lockRequested(m.getStartPar(), m.getEndPar(), m.getClientId())) {

      if (EditorServer_Debug) System.out.println("Lock Granted");

      Message.LockGrantMsg reply =
          new Message.LockGrantMsg(
              m.getClientId(), m.getStartPar(), m.getEndPar(), m.getIdNumber());
      try {
        textChannel.sendToOthers(client, new Data(reply));
      } catch (Exception e) {
        System.err.println("EditorServer: lockRequested: error sending lock granted");
        if (EditorServer_Debug) e.printStackTrace();
      }
    } else {
      if (EditorServer_Debug) System.out.println("Lock Denied");
      // send lock denied to sender

      Message.LockDenyMsg reply = new Message.LockDenyMsg(m.getClientId(), m.getIdNumber());
      try {
        textChannel.sendToOthers(client, new Data(reply));
      } catch (Exception e) {
        System.err.println("EditorServer: lockRequested: error sending lock denied");
        if (EditorServer_Debug) e.printStackTrace();
      }
    }
  }
Exemple #22
0
 @Override
 public void release(LockManager lockManager, Object resource, KernelTransaction tx) {
   lockManager.releaseWriteLock(resource, tx);
 }
Exemple #23
0
 private TaskExecutor(Context context) {
   mContext = context.getApplicationContext();
   mTaskQueue = new LinkedList<Task>();
   mLockManager = LockManager.get(mContext);
 }
 /**
  * Creates a new Lock for reading and increments counter for active readers. The lock is tracked
  * if lock tracking is enabled. This method is not thread safe itself, the calling method is
  * expected to handle synchronization issues.
  *
  * @return a read lock.
  */
 protected Lock createReadLock() {
   return activeReaders.createLock("Read");
 }
 /**
  * Blocks current thread until there are no reader locks active.
  *
  * @throws InterruptedException
  */
 protected void waitForActiveReaders() throws InterruptedException {
   activeReaders.waitForActiveLocks();
 }
 /**
  * Blocks current thread until after the writer lock is released (if active).
  *
  * @throws InterruptedException
  */
 protected void waitForActiveWriter() throws InterruptedException {
   activeWriter.waitForActiveLocks();
 }
 /** If one or more readers are active */
 protected boolean isReaderActive() {
   return activeReaders.isActiveLock();
 }
 /** If a writer is active */
 protected boolean isWriterActive() {
   return activeWriter.isActiveLock();
 }
 /**
  * Creates a new Lock for writing. The lock is tracked if lock tracking is enabled. This method is
  * not thread safe itself for performance reasons, the calling method is expected to handle
  * synchronization issues.
  *
  * @return a write lock.
  */
 protected Lock createWriteLock() {
   return activeWriter.createLock("Write");
 }
Exemple #30
0
 /** ロックが取得可能. */
 @Test
 public void ロックが取得可能() {
   Lock lock = LockManager.getLock(Lock.CATEGORY_ODATA, "aaa", null, null);
   assertNotNull(lock);
   lock.release();
 }