コード例 #1
0
  @Override
  protected boolean onAccessDenied(ServletRequest request, ServletResponse response)
      throws Exception {
    if (isLoginRequest(request, response)) {
      if (isLoginSubmission(request, response)) {
        if (logger.isTraceEnabled()) {
          logger.trace("Login submission detected.  Attempting to execute login.");
        }
        return executeLogin(request, response);
      } else {
        if (logger.isTraceEnabled()) {
          logger.trace("Login page view.");
        }
        // allow them to see the login page ;)
        return true;
      }
    } else {
      if (logger.isTraceEnabled()) {
        logger.trace(
            "Attempting to access a path which requires authentication.  Forwarding to the "
                + "Authentication url ["
                + getLoginUrl()
                + "]");
      }

      if (isMobileAppAccess(request)) {
        HttpServletResponse httpServletResponse = (HttpServletResponse) response;
        httpServletResponse.setStatus(HttpStatus.UNAUTHORIZED.value());
        return true;
      } else {
        saveRequestAndRedirectToLogin(request, response);
        return false;
      }
    }
  }
コード例 #2
0
ファイル: SimpleFilter.java プロジェクト: bashnesnos/grepp
  /**
   * Parses supplied filterPattern. If it contains any qualifiers like %and&|%or% parses them into
   * valid regex representation.
   *
   * @param val pattern String
   */
  protected void extractPatternParts(String val) {
    String qRegex = "";
    for (Qualifier it : Qualifier.values()) {
      qRegex += qRegex.length() > 0 ? "|%" + it + "%" : "%" + it + "%";
    }

    if (LOGGER.isTraceEnabled())
      LOGGER.trace("Trying to match supplied pattern /{}/ if it contains /{}/", val, qRegex);
    Matcher qualifierMatcher =
        Pattern.compile(qRegex).matcher(val); // matching any qualifiers with % signs
    if (qualifierMatcher.find()) {
      if (LOGGER.isTraceEnabled()) LOGGER.trace("Processing extended pattern");
      String[] tokens = val.split("%");
      String nextQualifier = null;
      if (tokens != null) {
        qRegex = qRegex.replaceAll("%", ""); // matching only qualifier names
        for (String grp : tokens) {
          if (LOGGER.isTraceEnabled()) LOGGER.trace("Next group in match: {}", grp);
          qualifierMatcher = Pattern.compile(qRegex).matcher(grp);
          if (qualifierMatcher.matches()) {
            nextQualifier = qualifierMatcher.group();
            continue;
          }

          addExtendedFilterPattern(grp, nextQualifier);
          nextQualifier = null;
        }
      } else throw new IllegalArgumentException("Check your extended pattern:/" + val + "/");
    } else {
      if (LOGGER.isTraceEnabled())
        LOGGER.trace("No extended pattern supplied; keeping things simple");
      patternBuilder.append(val);
    }
  }
コード例 #3
0
ファイル: QpidRAMessageProducer.java プロジェクト: ncdc/qpid
  /**
   * Send message
   *
   * @param message The message
   * @param deliveryMode The delivery mode
   * @param priority The priority
   * @param timeToLive The time to live
   * @exception JMSException Thrown if an error occurs
   */
  public void send(
      final Message message, final int deliveryMode, final int priority, final long timeToLive)
      throws JMSException {
    _session.lock();
    try {
      if (_log.isTraceEnabled()) {
        _log.trace(
            "send "
                + this
                + " message="
                + Util.asString(message)
                + " deliveryMode="
                + deliveryMode
                + " priority="
                + priority
                + " ttl="
                + timeToLive);
      }

      checkState();

      _producer.send(message, deliveryMode, priority, timeToLive);

      if (_log.isTraceEnabled()) {
        _log.trace("sent " + this + " result=" + Util.asString(message));
      }
    } finally {
      _session.unlock();
    }
  }
コード例 #4
0
  private void browseDir(ModelImpl model, File requestedFile) throws IOException {
    if (logger.isTraceEnabled()) logger.trace("> browseDir {}", requestedFile.getAbsolutePath());
    model.put("app", this);
    Map files = new HashMap();
    model.put("files", files);
    for (File file : requestedFile.listFiles()) {
      files.put(
          file.getName(),
          new Object[] {
            file,
            FileUtils.byteCountToDisplaySize(file.length()),
            DateTimeUtil.timestampForDisplay(file.lastModified())
          });
    }

    File indexFile = new File(requestedFile, "index.html");
    String selectedTemplate;
    if (indexFile.exists()) {
      selectedTemplate = FileUtils.readFileToString(indexFile);
    } else {
      selectedTemplate = dirTemplate;
    }
    String dirPage = StringTemplateUtils.render(selectedTemplate, model);
    model.getResponse().getWriter().println(dirPage);
    if (logger.isTraceEnabled()) logger.trace("< browseDir");
  }
コード例 #5
0
  private static void addEntry(final ZipOutputStream zos, final File file, final int bufferSize)
      throws IOException {
    if (log.isTraceEnabled()) log.trace(HelperLog.methodStart(zos, file, bufferSize));
    final byte[] buffer = new byte[bufferSize];

    // create a new zip entry
    final ZipEntry entry =
        new ZipEntry(
            file.getPath() + (file.isDirectory() ? "/" : HelperString.EMPTY_STRING)); // $NON-NLS-1$

    // place the zip entry in the ZipOutputStream object
    zos.putNextEntry(entry);

    if (!file.isDirectory()) {
      try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream(file))) {
        int offset;

        // now write the content of the file to the ZipOutputStream
        while (-1 != (offset = bis.read(buffer))) {
          zos.write(buffer, 0, offset);
        }
      }
    }
    if (log.isTraceEnabled()) log.trace(HelperLog.methodExit());
  }
コード例 #6
0
  @Override
  public void dispatchSendMessage(TBase<?, ?> tBase) {

    // mark accepted time
    acceptedTimeService.accept();

    // TODO consider to change dispatch table automatically
    SimpleHandler simpleHandler = getSimpleHandler(tBase);
    if (simpleHandler != null) {
      if (logger.isTraceEnabled()) {
        logger.trace("simpleHandler name:{}", simpleHandler.getClass().getName());
      }
      simpleHandler.handleSimple(tBase);
      return;
    }

    Handler handler = getHandler(tBase);
    if (handler != null) {
      if (logger.isTraceEnabled()) {
        logger.trace("handler name:{}", handler.getClass().getName());
      }
      handler.handle(tBase);
      return;
    }

    throw new UnsupportedOperationException(
        "Handler not found. Unknown type of data received. tBase=" + tBase);
  }
コード例 #7
0
 protected boolean writeBatch() {
   try {
     if (handler.getChannel().write(buffer) < 0) {
       if (log.isTraceEnabled()) {
         log.trace("Closing channel");
       }
       inError = true;
       return false;
     } else if (buffer.hasRemaining()) {
       if (handler.getChannel().write(buffer) < 0) {
         if (log.isTraceEnabled()) {
           log.trace("Closing channel");
         }
         inError = true;
         return false;
       }
     }
   } catch (IOException e) {
     if (Utils.isClose(e)) {
       log.info(String.format("closing acknowledger %s ", fsm.getName()));
     } else {
       log.warn(
           String.format("Unable to write batch commit acknowledgement %s", fsm.getName()), e);
     }
     error();
     return false;
   }
   return !buffer.hasRemaining();
 }
コード例 #8
0
  @Override
  public boolean checkPreconditions(ParseConfiguration configuration) {
    if (configuration.getStack().isEmpty()) {
      if (LOG.isTraceEnabled()) {
        LOG.trace("Cannot apply " + this.toString() + ": stack is empty");
      }
      return false;
    }

    // top of stack must already have a governor
    PosTaggedToken topOfStack = configuration.getStack().peek();
    PosTaggedToken governor = configuration.getHead(topOfStack);
    if (governor == null) {
      if (LOG.isTraceEnabled()) {
        LOG.trace(
            "Cannot apply "
                + this.toString()
                + ": top of stack "
                + topOfStack
                + " doesn't yet have a governor.");
      }
      return false;
    }

    return true;
  }
コード例 #9
0
  /** Return a bean from the bean cache. */
  @SuppressWarnings("unchecked")
  private T beanCacheGetInternal(Object id, Boolean readOnly, PersistenceContext context) {

    CachedBeanData data = (CachedBeanData) getBeanCache().get(id);
    if (data == null) {
      if (beanLog.isTraceEnabled()) {
        beanLog.trace("   GET {}({}) - cache miss", cacheName, id);
      }
      return null;
    }
    if (cacheSharableBeans && !Boolean.FALSE.equals(readOnly)) {
      Object bean = data.getSharableBean();
      if (bean != null) {
        if (beanLog.isTraceEnabled()) {
          beanLog.trace("   GET {}({}) - hit shared bean", cacheName, id);
        }
        if (desc.isReadAuditing()) {
          desc.readAuditBean("l2", "", bean);
        }
        return (T) bean;
      }
    }

    return (T) loadBean(id, readOnly, data, context);
  }
コード例 #10
0
  /** Returns true if it managed to populate/load the bean from the cache. */
  boolean beanCacheLoad(
      EntityBean bean, EntityBeanIntercept ebi, Object id, PersistenceContext context) {

    CachedBeanData cacheData = (CachedBeanData) getBeanCache().get(id);
    if (cacheData == null) {
      if (beanLog.isTraceEnabled()) {
        beanLog.trace("   LOAD {}({}) - cache miss", cacheName, id);
      }
      return false;
    }
    int lazyLoadProperty = ebi.getLazyLoadPropertyIndex();
    if (lazyLoadProperty > -1 && !cacheData.isLoaded(ebi.getLazyLoadProperty())) {
      if (beanLog.isTraceEnabled()) {
        beanLog.trace(
            "   LOAD {}({}) - cache miss on property({})",
            cacheName,
            id,
            ebi.getLazyLoadProperty());
      }
      return false;
    }

    CachedBeanDataToBean.load(desc, bean, cacheData, context);
    if (beanLog.isDebugEnabled()) {
      beanLog.debug("   LOAD {}({}) - hit", cacheName, id);
    }
    return true;
  }
コード例 #11
0
    @Override
    public OFMatchV3 readFrom(ChannelBuffer bb) throws OFParseError {
      int start = bb.readerIndex();
      // fixed value property type == 0x1
      short type = bb.readShort();
      if (type != (short) 0x1) throw new OFParseError("Wrong type: Expected=0x1(0x1), got=" + type);
      int length = U16.f(bb.readShort());
      if (length < MINIMUM_LENGTH)
        throw new OFParseError(
            "Wrong length: Expected to be >= " + MINIMUM_LENGTH + ", was: " + length);
      if (bb.readableBytes() + (bb.readerIndex() - start) < length) {
        // Buffer does not have all data yet
        bb.readerIndex(start);
        return null;
      }
      if (logger.isTraceEnabled()) logger.trace("readFrom - length={}", length);
      OFOxmList oxmList =
          OFOxmList.readFrom(bb, length - (bb.readerIndex() - start), OFOxmVer14.READER);
      // align message to 8 bytes (length does not contain alignment)
      bb.skipBytes(((length + 7) / 8 * 8) - length);

      OFMatchV3Ver14 matchV3Ver14 = new OFMatchV3Ver14(oxmList);
      if (logger.isTraceEnabled()) logger.trace("readFrom - read={}", matchV3Ver14);
      return matchV3Ver14;
    }
コード例 #12
0
    @Override
    public OFEchoRequest readFrom(ChannelBuffer bb) throws OFParseError {
      int start = bb.readerIndex();
      // fixed value property version == 1
      byte version = bb.readByte();
      if (version != (byte) 0x1)
        throw new OFParseError("Wrong version: Expected=OFVersion.OF_10(1), got=" + version);
      // fixed value property type == 2
      byte type = bb.readByte();
      if (type != (byte) 0x2)
        throw new OFParseError("Wrong type: Expected=OFType.ECHO_REQUEST(2), got=" + type);
      int length = U16.f(bb.readShort());
      if (length < MINIMUM_LENGTH)
        throw new OFParseError(
            "Wrong length: Expected to be >= " + MINIMUM_LENGTH + ", was: " + length);
      if (bb.readableBytes() + (bb.readerIndex() - start) < length) {
        // Buffer does not have all data yet
        bb.readerIndex(start);
        return null;
      }
      if (logger.isTraceEnabled()) logger.trace("readFrom - length={}", length);
      long xid = U32.f(bb.readInt());
      byte[] data = ChannelUtils.readBytes(bb, length - (bb.readerIndex() - start));

      OFEchoRequestVer10 echoRequestVer10 = new OFEchoRequestVer10(xid, data);
      if (logger.isTraceEnabled()) logger.trace("readFrom - read={}", echoRequestVer10);
      return echoRequestVer10;
    }
コード例 #13
0
    @Override
    public void run() {
      final long millisBeforeWarning =
          conf.getTimeInMillis(Property.TSERV_ASSIGNMENT_DURATION_WARNING);
      try {
        long now = System.currentTimeMillis();
        KeyExtent extent;
        RunnableStartedAt runnable;
        for (Entry<KeyExtent, RunnableStartedAt> entry : activeAssignments.entrySet()) {
          extent = entry.getKey();
          runnable = entry.getValue();
          final long duration = now - runnable.getStartTime();

          // Print a warning if an assignment has been running for over the configured time length
          if (duration > millisBeforeWarning) {
            log.warn(
                "Assignment for " + extent + " has been running for at least " + duration + "ms",
                runnable.getTask().getException());
          } else if (log.isTraceEnabled()) {
            log.trace("Assignment for " + extent + " only running for " + duration + "ms");
          }
        }
      } catch (Exception e) {
        log.warn("Caught exception checking active assignments", e);
      } finally {
        // Don't run more often than every 5s
        long delay = Math.max((long) (millisBeforeWarning * 0.5), 5000l);
        if (log.isTraceEnabled()) {
          log.trace("Rescheduling assignment watcher to run in " + delay + "ms");
        }
        timer.schedule(this, delay);
      }
    }
コード例 #14
0
  /**
   * Construct an HttpBasicAuthentication for the given challenge parameters. The challenge
   * parameters are returned by the web server using a WWW-Authenticate header. This will typically
   * be represented by single line of the form <code>WWW-Authenticate: Basic realm="myrealm"</code>
   *
   * @param challenge WWW-Authenticate header from web server
   */
  protected HttpBasicAuthentication(String challenge, Configuration conf)
      throws HttpAuthenticationException {

    setConf(conf);
    this.challenge = challenge;
    credentials = new ArrayList();

    String username = this.conf.get("http.auth.basic." + challenge + ".user");
    String password = this.conf.get("http.auth.basic." + challenge + ".password");

    if (LOG.isTraceEnabled()) {
      LOG.trace("BasicAuthentication challenge is " + challenge);
      LOG.trace("BasicAuthentication username="******"BasicAuthentication password="******"Username for " + challenge + " is null");
    }

    if (password == null) {
      throw new HttpAuthenticationException("Password for " + challenge + " is null");
    }

    byte[] credBytes = (username + ":" + password).getBytes();
    credentials.add("Authorization: Basic " + new String(Base64.encodeBase64(credBytes)));
    if (LOG.isTraceEnabled()) {
      LOG.trace("Basic credentials: " + credentials);
    }
  }
コード例 #15
0
    @Override
    public OFActionSetField readFrom(ChannelBuffer bb) throws OFParseError {
      int start = bb.readerIndex();
      // fixed value property type == 25
      short type = bb.readShort();
      if (type != (short) 0x19)
        throw new OFParseError("Wrong type: Expected=OFActionType.SET_FIELD(25), got=" + type);
      int length = U16.f(bb.readShort());
      if (length < MINIMUM_LENGTH)
        throw new OFParseError(
            "Wrong length: Expected to be >= " + MINIMUM_LENGTH + ", was: " + length);
      if (bb.readableBytes() + (bb.readerIndex() - start) < length) {
        // Buffer does not have all data yet
        bb.readerIndex(start);
        return null;
      }
      if (logger.isTraceEnabled()) logger.trace("readFrom - length={}", length);
      OFOxm<?> field = OFOxmVer12.READER.readFrom(bb);
      // align message to 8 bytes (length contains aligned value)
      bb.skipBytes(length - (bb.readerIndex() - start));

      OFActionSetFieldVer12 actionSetFieldVer12 = new OFActionSetFieldVer12(field);
      if (logger.isTraceEnabled()) logger.trace("readFrom - read={}", actionSetFieldVer12);
      return actionSetFieldVer12;
    }
コード例 #16
0
ファイル: XMLRestWorker.java プロジェクト: jormaral/SLdirect
  private Capacidad buscarCapacidad(int capacityCode) {
    HttpClient httpclient = getHttpClient();
    GetMethod get = new GetMethod(restUrl.getCapacidadUrl());
    get.addRequestHeader("Accept", "application/xml");
    Capacidad ret = null;
    try {
      int result = httpclient.executeMethod(get);
      if (logger.isTraceEnabled()) logger.trace("Response status code: " + result);
      String xmlString = get.getResponseBodyAsString();
      if (logger.isTraceEnabled()) logger.trace("Response body: " + xmlString);

      ret = importCapacidad(xmlString, capacityCode);
    } catch (HttpException e) {
      logger.error(e.getMessage());
    } catch (IOException e) {
      logger.error(e.getMessage());
    } catch (ParserConfigurationException e) {
      logger.error(e.getMessage());
    } catch (SAXException e) {
      logger.error(e.getMessage());
    } finally {
      get.releaseConnection();
    }
    return ret;
  }
コード例 #17
0
  /**
   * Gets the string body to be used when sending with the textline codec.
   *
   * @param body the current body
   * @param exchange the exchange
   * @param delimiter the textline delimiter
   * @param autoAppendDelimiter whether absent delimiter should be auto appended
   * @return the string body to send
   * @throws NoTypeConversionAvailableException is thrown if the current body could not be converted
   *     to a String type
   */
  public static String getTextlineBody(
      Object body, Exchange exchange, TextLineDelimiter delimiter, boolean autoAppendDelimiter)
      throws NoTypeConversionAvailableException {
    String s =
        exchange.getContext().getTypeConverter().mandatoryConvertTo(String.class, exchange, body);

    // auto append delimiter if missing?
    if (autoAppendDelimiter) {
      if (TextLineDelimiter.LINE.equals(delimiter)) {
        // line delimiter so ensure it ends with newline
        if (!s.endsWith("\n")) {
          if (LOG.isTraceEnabled()) {
            LOG.trace("Auto appending missing newline delimiter to body");
          }
          s = s + "\n";
        }
      } else {
        // null delimiter so ensure it ends with null
        if (!s.endsWith("\u0000")) {
          if (LOG.isTraceEnabled()) {
            LOG.trace("Auto appending missing null delimiter to body");
          }
          s = s + "\u0000";
        }
      }
    }

    return s;
  }
    @Override
    public OFInstructionIdBsnRequireVlanXlate readFrom(ChannelBuffer bb) throws OFParseError {
      int start = bb.readerIndex();
      // fixed value property type == 65535
      short type = bb.readShort();
      if (type != (short) 0xffff)
        throw new OFParseError(
            "Wrong type: Expected=OFInstructionType.EXPERIMENTER(65535), got=" + type);
      int length = U16.f(bb.readShort());
      if (length != 12) throw new OFParseError("Wrong length: Expected=12(12), got=" + length);
      if (bb.readableBytes() + (bb.readerIndex() - start) < length) {
        // Buffer does not have all data yet
        bb.readerIndex(start);
        return null;
      }
      if (logger.isTraceEnabled()) logger.trace("readFrom - length={}", length);
      // fixed value property experimenter == 0x5c16c7L
      int experimenter = bb.readInt();
      if (experimenter != 0x5c16c7)
        throw new OFParseError(
            "Wrong experimenter: Expected=0x5c16c7L(0x5c16c7L), got=" + experimenter);
      // fixed value property subtype == 0x8L
      int subtype = bb.readInt();
      if (subtype != 0x8)
        throw new OFParseError("Wrong subtype: Expected=0x8L(0x8L), got=" + subtype);

      if (logger.isTraceEnabled())
        logger.trace("readFrom - returning shared instance={}", INSTANCE);
      return INSTANCE;
    }
コード例 #19
0
  /**
   * Method description
   *
   * @param manager
   * @return
   * @throws IOException
   * @throws RepositoryException
   */
  @Override
  public List<String> importRepositories(RepositoryManager manager)
      throws IOException, RepositoryException {
    List<String> imported = new ArrayList<String>();

    if (logger.isTraceEnabled()) {
      logger.trace("search for repositories to import");
    }

    List<String> repositoryNames =
        RepositoryUtil.getRepositoryNames(getRepositoryHandler(), getDirectoryNames());

    for (String repositoryName : repositoryNames) {
      if (logger.isTraceEnabled()) {
        logger.trace("check repository {} for import", repositoryName);
      }

      Repository repository = manager.get(getTypeName(), repositoryName);

      if (repository == null) {
        importRepository(manager, repositoryName);
        imported.add(repositoryName);
      } else if (logger.isDebugEnabled()) {
        logger.debug("repository {} is allready managed", repositoryName);
      }
    }

    return imported;
  }
コード例 #20
0
  @Override
  public String processForm(Map<String, String> parameters, Map<String, FileItem> files)
      throws BadRequestException, NotAuthorizedException, ConflictException {
    log.trace("process");
    try {
      ByteArrayOutputStream bout = new ByteArrayOutputStream();
      Request request = HttpManager.request();
      IOUtils.copy(request.getInputStream(), bout);
      String iCalText = bout.toString("UTF-8");
      if (log.isTraceEnabled()) {
        log.trace("Freebusy query: " + iCalText);
      }
      List<SchedulingResponseItem> respItems = queryFreeBusy(iCalText);

      String xml = schedulingHelper.generateXml(respItems);
      xmlResponse = xml.getBytes(StringUtils.UTF8);
      if (log.isTraceEnabled()) {
        log.trace("FreeBusy response= " + xml);
      }

    } catch (IOException ex) {
      throw new RuntimeException(ex);
    }
    return null;
  }
コード例 #21
0
  /** 在访问被拒绝 */
  @Override
  protected boolean onAccessDenied(ServletRequest request, ServletResponse response)
      throws Exception {
    if (isLoginRequest(request, response)) {
      if (isLoginSubmission(request, response)) {
        if (log.isTraceEnabled()) {
          log.trace("Login submission detected.  Attempting to execute login.");
        }
        return executeLogin(request, response);
      } else {
        if (log.isTraceEnabled()) {
          log.trace("Login page view.");
        }
        return true;
      }
    } else {
      if (log.isTraceEnabled()) {
        log.trace(
            "Attempting to access a path which requires authentication.  Forwarding to the "
                + "Authentication url ["
                + getLoginUrl()
                + "]");
      }

      saveRequestAndRedirectToLogin(request, response);
      return false;
    }
  }
コード例 #22
0
 private boolean isManaged(
     RepositoryConnection conn, Resource subject, URI predicate, Value object, String operation) {
   try {
     if (conn.hasStatement(subject, predicate, object, true, managedContext)) {
       // Ignore/Strip any triple that is already present in the mgmt-context (i.e. "unchanged"
       // props).
       if (log.isTraceEnabled()) {
         log.trace(
             "[{}] filtering out statement that is already present in the managed context: {}",
             operation,
             new StatementImpl(subject, predicate, object));
       }
       return true;
     } else if (this.subject.equals(subject) && managedProperties.contains(predicate)) {
       // We do NOT allow changing server-managed properties.
       if (log.isTraceEnabled()) {
         log.trace(
             "[{}] filtering out statement with managed propterty {}: {}",
             operation,
             predicate,
             new StatementImpl(subject, predicate, object));
       }
       deniedProperties.add(predicate);
       return true;
     }
   } catch (RepositoryException e) {
     log.error("Error while filtering server managed properties: {}", e.getMessage());
   }
   return false;
 }
コード例 #23
0
    @Override
    public OFMeterFeaturesStatsReply readFrom(ByteBuf bb) throws OFParseError {
      int start = bb.readerIndex();
      // fixed value property version == 5
      byte version = bb.readByte();
      if (version != (byte) 0x5)
        throw new OFParseError("Wrong version: Expected=OFVersion.OF_14(5), got=" + version);
      // fixed value property type == 19
      byte type = bb.readByte();
      if (type != (byte) 0x13)
        throw new OFParseError("Wrong type: Expected=OFType.STATS_REPLY(19), got=" + type);
      int length = U16.f(bb.readShort());
      if (length != 32) throw new OFParseError("Wrong length: Expected=32(32), got=" + length);
      if (bb.readableBytes() + (bb.readerIndex() - start) < length) {
        // Buffer does not have all data yet
        bb.readerIndex(start);
        return null;
      }
      if (logger.isTraceEnabled()) logger.trace("readFrom - length={}", length);
      long xid = U32.f(bb.readInt());
      // fixed value property statsType == 11
      short statsType = bb.readShort();
      if (statsType != (short) 0xb)
        throw new OFParseError(
            "Wrong statsType: Expected=OFStatsType.METER_FEATURES(11), got=" + statsType);
      Set<OFStatsReplyFlags> flags = OFStatsReplyFlagsSerializerVer14.readFrom(bb);
      // pad: 4 bytes
      bb.skipBytes(4);
      OFMeterFeatures features = OFMeterFeaturesVer14.READER.readFrom(bb);

      OFMeterFeaturesStatsReplyVer14 meterFeaturesStatsReplyVer14 =
          new OFMeterFeaturesStatsReplyVer14(xid, flags, features);
      if (logger.isTraceEnabled()) logger.trace("readFrom - read={}", meterFeaturesStatsReplyVer14);
      return meterFeaturesStatsReplyVer14;
    }
コード例 #24
0
 /** {@inheritDoc} */
 @Override
 public void messageReceived(IoSession session, Object message) throws Exception {
   if (log.isTraceEnabled()) {
     log.trace("messageReceived session: {} message: {}", session, message);
     log.trace("Filter chain: {}", session.getFilterChain());
   }
   String sessionId = (String) session.getAttribute(RTMPConnection.RTMP_SESSION_ID);
   if (log.isTraceEnabled()) {
     log.trace("Message received on session: {} id: {}", session.getId(), sessionId);
   }
   RTMPMinaConnection conn =
       (RTMPMinaConnection) RTMPConnManager.getInstance().getConnectionBySessionId(sessionId);
   if (conn != null) {
     if (message != null) {
       if (message instanceof Packet) {
         byte state = conn.getStateCode();
         // checking the state before allowing a task to be created will hopefully prevent rejected
         // task exceptions
         if (state != RTMP.STATE_DISCONNECTING && state != RTMP.STATE_DISCONNECTED) {
           conn.handleMessageReceived((Packet) message);
         } else {
           log.info(
               "Ignoring received message on {} due to state: {}", sessionId, RTMP.states[state]);
         }
       }
     }
   } else {
     log.warn("Connection was not found for {}, force closing", sessionId);
     forceClose(session);
   }
 }
コード例 #25
0
ファイル: ReteAgenda.java プロジェクト: chearius/drools
 public void fireUntilHalt(final AgendaFilter agendaFilter) {
   unstageActivations();
   this.halt.set(false);
   if (log.isTraceEnabled()) {
     log.trace("Starting fireUntilHalt");
   }
   while (continueFiring(-1)) {
     boolean fired =
         fireNextItem(agendaFilter, 0, -1) >= 0
             || !((StatefulKnowledgeSessionImpl) this.workingMemory).getActionQueue().isEmpty();
     this.workingMemory.executeQueuedActions();
     if (!fired) {
       try {
         synchronized (this.halt) {
           if (!this.halt.get()) {
             this.halt.wait();
           }
         }
       } catch (InterruptedException e) {
         this.halt.set(true);
       }
     } else {
       this.workingMemory.executeQueuedActions();
     }
   }
   if (log.isTraceEnabled()) {
     log.trace("Ending fireUntilHalt");
   }
   fireUntilHalt = false;
 }
コード例 #26
0
ファイル: Port.java プロジェクト: olofsvensson/dawn-isencia
  /**
   * Send a token to all connected receivers. Tokens are in general immutable, so each receiver is
   * given a reference to the same token and no clones are made. The transfer is accomplished by
   * calling getRemoteReceivers() to determine the number of channels with valid receivers and then
   * calling send() on the appropriate channels. It would probably be faster to call put() directly
   * on the receivers. If there are no destination receivers, then nothing is sent. If the port is
   * not connected to anything, or receivers have not been created in the remote port, then just
   * return.
   *
   * <p>Some of this method is read-synchronized on the workspace. Since it is possible for a thread
   * to block while executing a put, it is important that the thread does not hold read access on
   * the workspace when it is blocked. Thus this method releases read access on the workspace before
   * calling put.
   *
   * @param token The token to send
   * @exception IllegalActionException If the token to be sent cannot be converted to the type of
   *     this port
   * @exception NoRoomException If a send to one of the channels throws it.
   */
  public void broadcast(Token token) throws IllegalActionException, NoRoomException {

    if (logger.isTraceEnabled()) {
      logger.trace("broadcast() - entry : " + token);
    }

    statistics.acceptSentMessage(null);

    Receiver[][] farReceivers;
    // ptolemy debug listener stuff etc
    if (_debugging) {
      _debug("broadcast " + token);
    }
    try {
      _workspace.getReadAccess();
      _checkType(token);
      farReceivers = getRemoteReceivers();
      if (farReceivers == null) {
        return;
      }
    } finally {
      _workspace.doneReading();
    }
    // NOTE: This does not call send() here, because send()
    // repeats the above on each call.
    for (int i = 0; i < farReceivers.length; i++) {
      if (farReceivers[i] == null) continue;
      putAtFarReceivers(token, farReceivers[i]);
    }

    if (logger.isTraceEnabled()) {
      logger.trace("broadcast() - exit");
    }
  }
コード例 #27
0
    @Override
    public OFQueueOpFailedErrorMsg readFrom(ChannelBuffer bb) throws OFParseError {
      int start = bb.readerIndex();
      // fixed value property version == 4
      byte version = bb.readByte();
      if (version != (byte) 0x4)
        throw new OFParseError("Wrong version: Expected=OFVersion.OF_13(4), got=" + version);
      // fixed value property type == 1
      byte type = bb.readByte();
      if (type != (byte) 0x1)
        throw new OFParseError("Wrong type: Expected=OFType.ERROR(1), got=" + type);
      int length = U16.f(bb.readShort());
      if (length < MINIMUM_LENGTH)
        throw new OFParseError(
            "Wrong length: Expected to be >= " + MINIMUM_LENGTH + ", was: " + length);
      if (bb.readableBytes() + (bb.readerIndex() - start) < length) {
        // Buffer does not have all data yet
        bb.readerIndex(start);
        return null;
      }
      if (logger.isTraceEnabled()) logger.trace("readFrom - length={}", length);
      long xid = U32.f(bb.readInt());
      // fixed value property errType == 9
      short errType = bb.readShort();
      if (errType != (short) 0x9)
        throw new OFParseError(
            "Wrong errType: Expected=OFErrorType.QUEUE_OP_FAILED(9), got=" + errType);
      OFQueueOpFailedCode code = OFQueueOpFailedCodeSerializerVer13.readFrom(bb);
      byte[] data = ChannelUtils.readBytes(bb, length - (bb.readerIndex() - start));

      OFQueueOpFailedErrorMsgVer13 queueOpFailedErrorMsgVer13 =
          new OFQueueOpFailedErrorMsgVer13(xid, code, data);
      if (logger.isTraceEnabled()) logger.trace("readFrom - read={}", queueOpFailedErrorMsgVer13);
      return queueOpFailedErrorMsgVer13;
    }
コード例 #28
0
  private int scpExec(Map<String, ?> props, String from, String to) {
    File tempFile = null;
    try {
      List<String> cmd = Lists.newArrayList();
      cmd.add(getOptionalVal(props, PROP_SCP_EXECUTABLE, scpExecutable));
      cmd.add("-B");
      if (privateKeyFile != null) {
        cmd.add("-i");
        cmd.add(privateKeyFile.getAbsolutePath());
      } else if (privateKeyData != null) {
        tempFile = writeTempFile(privateKeyData);
        cmd.add("-i");
        cmd.add(tempFile.getAbsolutePath());
      }
      if (!strictHostKeyChecking) {
        cmd.add("-o");
        cmd.add("StrictHostKeyChecking=no");
      }
      if (port != 22) {
        cmd.add("-P");
        cmd.add("" + port);
      }
      cmd.add(from);
      cmd.add(to);

      if (LOG.isTraceEnabled()) LOG.trace("Executing with command: {}", cmd);
      int result = execProcess(props, cmd);

      if (LOG.isTraceEnabled()) LOG.trace("Executed command: {}; exit code {}", cmd, result);
      return result;

    } finally {
      if (tempFile != null) tempFile.delete();
    }
  }
コード例 #29
0
ファイル: Forwarding.java プロジェクト: basavesh/floodlight
  /**
   * Creates a OFPacketOut with the OFPacketIn data that is flooded on all ports unless the port is
   * blocked, in which case the packet will be dropped.
   *
   * @param sw The switch that receives the OFPacketIn
   * @param pi The OFPacketIn that came to the switch
   * @param cntx The FloodlightContext associated with this OFPacketIn
   */
  @LogMessageDoc(
      level = "ERROR",
      message =
          "Failure writing PacketOut "
              + "switch={switch} packet-in={packet-in} "
              + "packet-out={packet-out}",
      explanation = "An I/O error occured while writing a packet " + "out message to the switch",
      recommendation = LogMessageDoc.CHECK_SWITCH)
  protected void doFlood(IOFSwitch sw, OFPacketIn pi, FloodlightContext cntx) {
    if (topology.isIncomingBroadcastAllowed(sw.getId(), pi.getInPort()) == false) {
      if (log.isTraceEnabled()) {
        log.trace(
            "doFlood, drop broadcast packet, pi={}, "
                + "from a blocked port, srcSwitch=[{},{}], linkInfo={}",
            new Object[] {pi, sw.getId(), pi.getInPort()});
      }
      return;
    }

    // Set Action to flood
    OFPacketOut po =
        (OFPacketOut) floodlightProvider.getOFMessageFactory().getMessage(OFType.PACKET_OUT);
    List<OFAction> actions = new ArrayList<OFAction>();
    if (sw.hasAttribute(IOFSwitch.PROP_SUPPORTS_OFPP_FLOOD)) {
      actions.add(new OFActionOutput(OFPort.OFPP_FLOOD.getValue(), (short) 0xFFFF));
    } else {
      actions.add(new OFActionOutput(OFPort.OFPP_ALL.getValue(), (short) 0xFFFF));
    }
    po.setActions(actions);
    po.setActionsLength((short) OFActionOutput.MINIMUM_LENGTH);

    // set buffer-id, in-port and packet-data based on packet-in
    short poLength = (short) (po.getActionsLength() + OFPacketOut.MINIMUM_LENGTH);
    po.setBufferId(pi.getBufferId());
    po.setInPort(pi.getInPort());
    if (pi.getBufferId() == OFPacketOut.BUFFER_ID_NONE) {
      byte[] packetData = pi.getPacketData();
      poLength += packetData.length;
      po.setPacketData(packetData);
    }
    po.setLength(poLength);

    try {
      if (log.isTraceEnabled()) {
        log.trace(
            "Writing flood PacketOut switch={} packet-in={} packet-out={}",
            new Object[] {sw, pi, po});
      }
      messageDamper.write(sw, po, cntx);
    } catch (IOException e) {
      log.error(
          "Failure writing PacketOut switch={} packet-in={} packet-out={}",
          new Object[] {sw, pi, po},
          e);
    }

    return;
  }
コード例 #30
0
ファイル: Forwarding.java プロジェクト: basavesh/floodlight
  @Override
  @LogMessageDoc(
      level = "ERROR",
      message = "Unexpected decision made for this packet-in={}",
      explanation =
          "An unsupported PacketIn decision has been " + "passed to the flow programming component",
      recommendation = LogMessageDoc.REPORT_CONTROLLER_BUG)
  public Command processPacketInMessage(
      IOFSwitch sw, OFPacketIn pi, IRoutingDecision decision, FloodlightContext cntx) {
    Ethernet eth =
        IFloodlightProviderService.bcStore.get(cntx, IFloodlightProviderService.CONTEXT_PI_PAYLOAD);

    // If a decision has been made we obey it
    // otherwise we just forward
    if (decision != null) {
      if (log.isTraceEnabled()) {
        log.trace(
            "Forwaring decision={} was made for PacketIn={}",
            decision.getRoutingAction().toString(),
            pi);
      }

      switch (decision.getRoutingAction()) {
        case NONE:
          // don't do anything
          return Command.CONTINUE;
        case FORWARD_OR_FLOOD:
        case FORWARD:
          doForwardFlow(sw, pi, cntx, false);
          return Command.CONTINUE;
        case MULTICAST:
          // treat as broadcast
          doFlood(sw, pi, cntx);
          return Command.CONTINUE;
        case DROP:
          doDropFlow(sw, pi, decision, cntx);
          return Command.CONTINUE;
        default:
          log.error(
              "Unexpected decision made for this packet-in={}", pi, decision.getRoutingAction());
          return Command.CONTINUE;
      }
    } else {
      if (log.isTraceEnabled()) {
        log.trace("No decision was made for PacketIn={}, forwarding", pi);
      }

      if (eth.isBroadcast() || eth.isMulticast()) {
        // For now we treat multicast as broadcast
        doFlood(sw, pi, cntx);
      } else {
        doForwardFlow(sw, pi, cntx, false);
      }
    }

    return Command.CONTINUE;
  }