Esempio n. 1
0
 public void invoke(
     Pointer streamRef,
     Pointer clientCallBackInfo,
     NativeLong numEvents,
     Pointer eventPaths,
     Pointer eventFlags,
     Pointer eventIds) {
   final long st = System.currentTimeMillis();
   final int length = numEvents.intValue();
   final Pointer[] pointers = eventPaths.getPointerArray(0, length);
   final int[] flags = eventFlags.getIntArray(0, length);
   for (int i = 0; i < length; i++) {
     final Pointer p = pointers[i];
     final int flag = flags[i];
     boolean found = false;
     final String path = p.getString(0);
     final Key key = listensOn.get(path);
     if (key != null) {
       if ((flag & kFSEventStreamEventFlagMustScanSubDirs)
               == kFSEventStreamEventFlagMustScanSubDirs
           || (flag & kFSEventStreamEventFlagMount) == kFSEventStreamEventFlagMount
           || (flag & kFSEventStreamEventFlagUnmount) == kFSEventStreamEventFlagUnmount) {
         events.add(createEvent(key, EventKind.OVERFLOW, path));
       } else {
         events.add(createEvent(key, EventKind.MODIFY, path));
       }
       found = true;
     }
     LOG.log(DEBUG_LOG_LEVEL, "Event on {0} interesting: {1}", new Object[] {path, found});
   }
   LOG.log(PERF_LOG_LEVEL, "Callback time: {0}", (System.currentTimeMillis() - st));
 }
Esempio n. 2
0
 @Override
 public ByteBuffer readPage(File file, long position, ByteBuffer pageBuffer)
     throws IOException, InterruptedException {
   long start = System.currentTimeMillis();
   RandomAccessFile randomAccessFile = randomAccessFile(file);
   try {
     randomAccessFile.seek(position);
     randomAccessFile.readFully(pageBuffer.array(), pageBuffer.arrayOffset(), pageSizeBytes);
     if (Thread.interrupted()) {
       throw new InterruptedException();
     }
     long stop = System.currentTimeMillis();
     if (LOG.isLoggable(Level.FINE)) {
       LOG.log(
           Level.FINE,
           "Read page at {0} of {1}: {2} msec",
           new Object[] {position, file, stop - start});
     }
   } catch (EOFException e) {
     LOG.log(
         Level.SEVERE,
         "Caught EOFException while reading {0}, position {1}",
         new Object[] {file, position});
     LOG.log(Level.SEVERE, "stack", e);
     throw e;
   } finally {
     randomAccessFile.close();
   }
   return pageBuffer;
 }
Esempio n. 3
0
  public List<User> getAll() {

    try {

      connection = connectionFactory.getConnection();

      String sql = "SELECT * FROM eeproject.Login;";
      Statement statement = connection.createStatement();

      ResultSet rs = statement.executeQuery(sql);

      while (rs.next()) {
        User user = new User();
        user.setUsername(rs.getString(1));
        user.setPassword(rs.getString(2));

        LOG.log(Level.INFO, "User: "******"List size: " + list.size());
      }

    } catch (SQLException ex) {
      LOG.log(Level.SEVERE, null, ex);
    } finally {
      connectionFactory.closeConnection();
      LOG.log(Level.INFO, "Connection closed");
    }

    return list;
  }
Esempio n. 4
0
 @Override
 public void resultChanged(LookupEvent ev) {
   TopComponent tc = ref.get();
   if (tc == null) {
     r.removeLookupListener(this);
     synchronized (lookupListeners) {
       lookupListeners.remove(this);
     }
     return;
   }
   if (LOG.isLoggable(Level.FINER)) {
     LOG.log(Level.FINER, "  looking result changed for {0} ", new Object[] {ref.get()});
   }
   DataObject tcDataObject = tc.getLookup().lookup(DataObject.class);
   if (tcDataObject != null) {
     try {
       if (hasOpenedEditorPanes(tcDataObject)) {
         addOpenedFiles(getFiles(tcDataObject));
       }
     } catch (InterruptedException ex) {
       LOG.log(Level.WARNING, null, ex);
     } catch (InvocationTargetException ex) {
       LOG.log(Level.WARNING, null, ex);
     }
     r.removeLookupListener(this);
     synchronized (lookupListeners) {
       lookupListeners.remove(this);
     }
   }
 }
    public final void run() {
      byte[] buf = new byte[PayloadUtil.MTU];
      try {
        while (!stopped) {
          DatagramPacket packet = new DatagramPacket(buf, buf.length);
          try {
            socket.receive(packet);
            byte[] payload = packet.getData();
            processPayload(payload);

          } catch (IOException e) {
            if (!stopped) {
              LOG.log(
                  Level.SEVERE,
                  "Error receiving heartbeat. "
                      + e.getMessage()
                      + ". Initial cause was "
                      + e.getMessage(),
                  e);
            }
          }
        }
      } catch (Throwable t) {
        LOG.log(
            Level.SEVERE,
            "Multicast receiver thread caught throwable. Cause was "
                + t.getMessage()
                + ". Continuing...");
      }
    }
Esempio n. 6
0
 private ErdoTransactionTest(String[] args) throws IOException, InterruptedException {
   // Database setup
   FileUtil.deleteDirectory(DB_DIRECTORY);
   db = Database.createDatabase(DB_DIRECTORY, configuration());
   accounts = db.createMap(MAP_NAME, AccountId.class, Account.class);
   int a = 0;
   this.nAccounts = Integer.parseInt(args[a++]);
   this.threads = new ErdoTestThread[Integer.parseInt(args[a++])];
   this.transactionsPerThread = Integer.parseInt(args[a++]);
   LOG.log(Level.INFO, "accounts: {0}", nAccounts);
   LOG.log(Level.INFO, "threads: {0}", threads.length);
   LOG.log(Level.INFO, "transactions per thread: {0}", transactionsPerThread);
 }
Esempio n. 7
0
 private void verify() throws IOException, InterruptedException {
   long sum = 0;
   Cursor cursor = accounts.first();
   Account account;
   while ((account = (Account) cursor.next()) != null) {
     LOG.log(Level.INFO, "{0}", account);
     sum += account.balance();
   }
   db.commitTransaction();
   if (sum == 0) {
     LOG.log(Level.INFO, "OK!");
   } else {
     LOG.log(Level.WARNING, "Test failed, sum = {0}", sum);
   }
 }
Esempio n. 8
0
 @Nullable
 @Override
 public InputStream openStream() {
   if (uri == null) return null;
   try {
     return new BufferedInputStream(new URI(uri).toURL().openStream());
   } catch (FileNotFoundException e) {
     LOG.log(Level.SEVERE, "File not found", e);
   } catch (IOException e) {
     LOG.log(Level.SEVERE, "Other IO error", e);
   } catch (URISyntaxException e) {
     LOG.log(Level.SEVERE, "Bad URI", e);
   }
   return null;
 }
Esempio n. 9
0
 private void deliver() {
   try {
     executor.execute(this);
   } catch (Throwable t) {
     LOG.log(Level.INFO, "Exception notifying context listener", t);
   }
 }
Esempio n. 10
0
    protected final synchronized void schedule() {
      if (null == manager.getTimer()) {
        return;
      }
      class ResendTask extends TimerTask {
        ResendCandidate candidate;

        ResendTask(ResendCandidate c) {
          candidate = c;
        }

        @Override
        public void run() {
          if (!candidate.isPending()) {
            candidate.initiate(includeAckRequested);
          }
        }
      }
      nextTask = new ResendTask(this);
      try {
        manager.getTimer().schedule(nextTask, next);
      } catch (IllegalStateException ex) {
        LOG.log(Level.WARNING, "SCHEDULE_RESEND_FAILED_MSG", ex);
      }
    }
Esempio n. 11
0
    /** @param ctx message context for the unacked message */
    protected ResendCandidate(Message m) {
      message = m;
      retries = 0;
      RMConfiguration cfg = manager.getEffectiveConfiguration(message);
      long baseRetransmissionInterval = cfg.getBaseRetransmissionInterval().longValue();
      backoff = cfg.isExponentialBackoff() ? RetransmissionQueue.DEFAULT_EXPONENTIAL_BACKOFF : 1;
      next = new Date(System.currentTimeMillis() + baseRetransmissionInterval);
      nextInterval = baseRetransmissionInterval * backoff;
      RetryPolicyType rmrp =
          null != manager.getSourcePolicy() ? manager.getSourcePolicy().getRetryPolicy() : null;
      maxRetries = null != rmrp ? rmrp.getMaxRetries() : -1;

      AddressingProperties maps = RMContextUtils.retrieveMAPs(message, false, true);
      AttributedURIType to = null;
      if (null != maps) {
        to = maps.getTo();
      }
      if (to != null && RMUtils.getAddressingConstants().getAnonymousURI().equals(to.getValue())) {
        LOG.log(Level.INFO, "Cannot resend to anonymous target.  Not scheduling a resend.");
        return;
      }
      RMProperties rmprops = RMContextUtils.retrieveRMProperties(message, true);
      if (null != rmprops) {
        number = rmprops.getSequence().getMessageNumber();
      }
      if (null != manager.getTimer() && maxRetries != 0) {
        schedule();
      }
    }
Esempio n. 12
0
    @Override
    public void onClose(CachedOutputStream cos) {
      long l = LOG.logStart();
      byte[] buf = new byte[1024];
      int len;
      InputStream is;
      try {
        is = cos.getInputStream();
        while ((len = is.read(buf)) > 0) {
          logOutputStream.write(buf, 0, len);
        }
      } catch (IOException ex) {
        LOG.logError(l, ex);
      }
      LoggingMessage buffer = setupBuffer(message, fout);
      LOG.log(buffer.toString());

      try {
        // empty out the cache
        cos.lockOutputStream();
        cos.resetOut(null, false);
      } catch (Exception ex) {
        LOG.logWarn(l, "Error clearing cache: " + ex.getMessage(), null);
      }
      message.setContent(OutputStream.class, origStream);
    }
 private void change(FileEvent fe) {
   synchronized (saveActions) {
     for (AtomicAction a : saveActions) {
       if (fe.firedFrom(a)) {
         return;
       }
     }
   }
   String path;
   FileObject f = fe.getFile();
   synchronized (modifiedMetadataPaths) {
     if (f.equals(resolveFileObject(PROJECT_XML_PATH))) {
       if (modifiedMetadataPaths.contains(PROJECT_XML_PATH)) {
         // #68872: don't do anything if the given file has non-saved changes:
         return;
       }
       path = PROJECT_XML_PATH;
       projectXmlValid = false;
     } else if (f.equals(resolveFileObject(PRIVATE_XML_PATH))) {
       if (modifiedMetadataPaths.contains(PRIVATE_XML_PATH)) {
         // #68872: don't do anything if the given file has non-saved changes:
         return;
       }
       path = PRIVATE_XML_PATH;
       privateXmlValid = false;
     } else {
       LOG.log(
           Level.WARNING,
           "#184132: unexpected file change in {0}; possibly deleted project?",
           f);
       return;
     }
   }
   fireExternalChange(path);
 }
Esempio n. 14
0
 @Override
 public long length() {
   if (uri == null) return list().size(); // Directory
   try {
     @NotNull URI u = new URI(uri);
     try {
       int length = u.toURL().openConnection().getContentLength();
       if (length >= 0) return length;
     } catch (IOException e) {
       LOG.log(Level.SEVERE, "Bad URL", e);
     }
   } catch (URISyntaxException e) {
     LOG.log(Level.SEVERE, "Bad URI", e);
   }
   return super.length();
 }
Esempio n. 15
0
 /** {@inheritDoc}. */
 public String getContentType() {
   try {
     return myMessage.getContentType();
   } catch (MessagingException e) {
     LOG.log(Level.SEVERE, "Exception while getting content-type", e);
     return "text/plain";
   }
 }
 private CalculateCoauthorsResearcherProcessor(String researcherURI, String affiliationURI) {
   super(researcherURI);
   try {
     affiliation = store.findAffiliationFor(affiliationURI);
   } catch (Exception e) {
     LOG.log(Level.SEVERE, "Exception finding affiliation" + affiliationURI, e);
   }
 }
Esempio n. 17
0
 /** {@inheritDoc}. */
 public InputStream getInputStream() throws IOException {
   try {
     return (InputStream) myMessage.getContent();
   } catch (MessagingException e) {
     LOG.log(Level.SEVERE, "Exception while getting content", e);
     return null;
   }
 }
 /** Thread runner. Calls the synch method. */
 public void run() {
   try {
     synch();
   } catch (Throwable e) {
     LOG.log(
         Level.WARNING, "Error while synchronizing rest criteria with " + "session criteria", e);
   }
 }
Esempio n. 19
0
  /** Обработчик всех событий помещенных в очередь */
  void processEvents() {
    for (; ; ) {

      WatchKey key;
      try {
        key = watcher.take();
      } catch (InterruptedException x) {
        LOG.log(Level.SEVERE, x.getMessage());
        return;
      }

      Path dir = keys.get(key);
      if (dir == null) {
        LOG.log(Level.SEVERE, "Входной каталог не найден!");
        continue;
      }

      for (WatchEvent<?> event : key.pollEvents()) {
        WatchEvent.Kind kind = event.kind();

        // TODO - подумать над обработчиком события OVERFLOW
        if (kind == OVERFLOW) {
          continue;
        }

        WatchEvent<Path> ev = cast(event);
        Path name = ev.context();
        Path child = dir.resolve(name);

        // логируем событие
        if (kind == ENTRY_CREATE) {
          LOG.log(Level.FINEST, "{0}: {1}", new Object[] {event.kind().name(), child});
          Runnable worker = new WorkerThread(child);
          executor.execute(worker);
        }
      }

      boolean valid = key.reset();
      if (!valid) {
        keys.remove(key);
        if (keys.isEmpty()) {
          break;
        }
      }
    }
  }
Esempio n. 20
0
 @Override
 public void onNext(final FailedTask task) {
   LOG.log(Level.WARNING, "Task failed: " + task.getId(), task.getReason().orElse(null));
   checkMsgOrder(task);
   if (task.getActiveContext().isPresent()) {
     task.getActiveContext().get().close();
   }
 }
Esempio n. 21
0
 @Override
 public void run() {
   while (true) {
     try {
       final U value = queue.take();
       handler.onNext(value);
       SingleThreadStage.this.afterOnNext();
     } catch (final InterruptedException e) {
       if (interrupted.get()) {
         LOG.log(Level.FINEST, name + " Closing Producer due to interruption");
         break;
       }
     } catch (final Throwable t) {
       LOG.log(Level.SEVERE, name + " Exception from event handler", t);
       throw t;
     }
   }
 }
 public boolean afterInsert(final Object key, final Object value, final Object version)
     throws CacheException {
   try {
     return put(key, value, version, null);
   } catch (TimeoutException e) {
     LOG.log(Level.FINEST, e.getMessage());
   }
   return false;
 }
 /** {@inheritDoc} */
 public final void interrupt() {
   try {
     socket.leaveGroup(groupMulticastAddress);
   } catch (IOException e) {
     LOG.log(Level.SEVERE, "Error leaving group");
   }
   socket.close();
   super.interrupt();
 }
Esempio n. 24
0
 public DiskPage page(
     TreeSegment segment, int pageNumber, ImmutableItemManager<PageId, DiskPage> diskPageReader)
     throws IOException, InterruptedException {
   PageId pageId = new PageId(segment.segmentId(), pageNumber);
   if (LOG.isLoggable(Level.FINE)) {
     LOG.log(Level.FINE, "read {0}", pageId);
   }
   return find(pageId, diskPageReader);
 }
Esempio n. 25
0
 public synchronized void delete(List<Element> obsolete) {
   if (!obsolete.isEmpty()) {
     if (LOG.isLoggable(Level.INFO)) {
       LOG.log(Level.INFO, "Deleting {0}", obsolete);
     }
     this.queue.addAll(obsolete);
     notify();
   }
 }
    @Override
    public void run() {
      try {

        Set<String> serviceNames = serviceMap.keySet();

        Map<String, List<RegisterInfo>> eServcieMap =
            loadBalancer.getNamingService().list(serviceNames);
        if (eServcieMap == null) {
          eServcieMap = Collections.emptyMap();
        }

        Iterator<Entry<String, List<RegisterInfo>>> iter = serviceMap.entrySet().iterator();
        while (iter.hasNext()) {
          Entry<String, List<RegisterInfo>> next = iter.next();
          String service = next.getKey();
          List<RegisterInfo> oldList = next.getValue();
          if (oldList == null) {
            oldList = Collections.emptyList();
          }
          List<RegisterInfo> newList = eServcieMap.get(service);
          if (newList == null) {
            newList = Collections.emptyList();
          }

          if (oldList.equals(newList)) {
            continue;
          }

          LOG.log(
              Level.WARNING,
              "A new changed list geting from naming service name='"
                  + service
                  + "' "
                  + "value="
                  + newList);
          List<RegisterInfo> list = new ArrayList<RegisterInfo>(newList);
          next.setValue(list);
          reInit(service, list);
        }
      } catch (Exception e) {
        LOG.log(Level.WARNING, e.getMessage(), e.getCause());
      }
    }
Esempio n. 27
0
    @Override
    public void onNext(final FailedContext context) {
      LOG.log(
          Level.WARNING, "Context failed: " + context.getId(), context.getReason().orElse(null));
      checkMsgOrder(context);

      // if (context.getParentContext().isPresent()) {
      //   context.getParentContext().get().close();
      // }
    }
Esempio n. 28
0
 /*
  * (non-Javadoc)
  * @see
  * com.almende.eve.state.StateService#delete(com.almende.eve.state.State)
  */
 @Override
 public void delete(final State instance, final Boolean instanceOnly) {
   if (!instanceOnly) {
     try {
       getCollection().remove("{_id: #}", instance.getId());
     } catch (final Exception e) {
       LOG.log(Level.WARNING, "delete error", e);
     }
   }
 }
Esempio n. 29
0
    @Override
    public void onClose(final int code, final String reason) {
      LOG.log(Level.FINE, "WebSocket onClose {0}/{1}", new Object[] {code, reason});
      Socket.this.webSocket = null;
      scheduleReconnectTimer();

      for (final ISocketCloseCallback callback : socketCloseCallbacks) {
        callback.onClose();
      }
    }
Esempio n. 30
0
 @Override
 public void startProgramUse(GL2 gl) {
   if (linkedProgram == 0 || linkedShader == 0) {
     LOG.log(Level.WARNING, "No Shader-Program linked");
   } else {
     gl.glUseProgram(linkedProgram);
     UniformUtil.setUniform1i(gl, linkedShader, UNIFORM_NAME_SAMPLER0, 0);
     gl.glValidateProgram(linkedProgram);
   }
 }