private void createPlaylist() {
    String showName = MediaFileAPI.GetMediaTitle(mediaFile);
    int numberOfMediaFileSegments = MediaFileAPI.GetNumberOfSegments(mediaFile);
    Log.debug("Number of media file segments: " + numberOfMediaFileSegments);

    for (int i = 0; i < numberOfMediaFileSegments; i++) {
      // get length of current media file segment
      long mediaFileSegmentDurationInMillis = MediaFileAPI.GetDurationForSegment(mediaFile, i);
      long mediaFileSegmentDurationInSeconds =
          mediaFileSegmentDurationInMillis / 1000; // milliseconds to seconds
      Log.debug(
          "mediaFileSegmentDurationInMillis (" + i + "): " + mediaFileSegmentDurationInMillis);
      Log.debug(
          "mediaFileSegmentDurationInSeconds (" + i + "): " + mediaFileSegmentDurationInSeconds);

      int sequence = 0;
      for (int j = 0; j < mediaFileSegmentDurationInSeconds; j += SegmentPlaylist.TARGET_DURATION) {
        long currentDuration =
            Math.min(SegmentPlaylist.TARGET_DURATION, mediaFileSegmentDurationInSeconds - j);

        Segment newSegment = new Segment(currentDuration, sequence, i, showName);

        segmentList.add(newSegment);

        sequence++;
      }
    }
    if (segmentList != null) {
      Log.debug("segmentList size: " + segmentList.size());
    }
  }
  /* ------------------------------------------------------------ */
  protected void doStart() throws Exception {
    if (_server == null) throw new IllegalStateException("No server");

    // open listener port
    open();

    super.doStart();

    if (_threadPool == null) _threadPool = _server.getThreadPool();
    if (_threadPool != _server.getThreadPool() && (_threadPool instanceof LifeCycle))
      ((LifeCycle) _threadPool).start();

    // Start selector thread
    synchronized (this) {
      _acceptorThread = new Thread[getAcceptors()];

      for (int i = 0; i < _acceptorThread.length; i++) {
        if (!_threadPool.dispatch(new Acceptor(i))) {
          Log.warn("insufficient maxThreads configured for {}", this);
          break;
        }
      }
    }

    Log.info("Started {}", this);
  }
Beispiel #3
0
 static {
   try {
     org.mortbay.log.Log.setLog(new org.mortbay.log.Slf4jLog());
   } catch (Throwable t) {
     logger.error(t.getMessage(), t);
   }
 }
  public NodeHeartbeatResponse nodeHeartbeat(
      Map<ApplicationId, List<ContainerStatus>> conts, boolean isHealthy, int resId)
      throws Exception {
    NodeHeartbeatRequest req = Records.newRecord(NodeHeartbeatRequest.class);
    NodeStatus status = Records.newRecord(NodeStatus.class);
    status.setResponseId(resId);
    status.setNodeId(nodeId);
    for (Map.Entry<ApplicationId, List<ContainerStatus>> entry : conts.entrySet()) {
      Log.info("entry.getValue() " + entry.getValue());
      status.setContainersStatuses(entry.getValue());
    }
    NodeHealthStatus healthStatus = Records.newRecord(NodeHealthStatus.class);
    healthStatus.setHealthReport("");
    healthStatus.setIsNodeHealthy(isHealthy);
    healthStatus.setLastHealthReportTime(1);
    status.setNodeHealthStatus(healthStatus);
    req.setNodeStatus(status);
    req.setLastKnownContainerTokenMasterKey(this.currentContainerTokenMasterKey);
    req.setLastKnownNMTokenMasterKey(this.currentNMTokenMasterKey);
    NodeHeartbeatResponse heartbeatResponse = resourceTracker.nodeHeartbeat(req);

    MasterKey masterKeyFromRM = heartbeatResponse.getContainerTokenMasterKey();
    if (masterKeyFromRM != null
        && masterKeyFromRM.getKeyId() != this.currentContainerTokenMasterKey.getKeyId()) {
      this.currentContainerTokenMasterKey = masterKeyFromRM;
    }

    masterKeyFromRM = heartbeatResponse.getNMTokenMasterKey();
    if (masterKeyFromRM != null
        && masterKeyFromRM.getKeyId() != this.currentNMTokenMasterKey.getKeyId()) {
      this.currentNMTokenMasterKey = masterKeyFromRM;
    }

    return heartbeatResponse;
  }
  public ArrayList fiterOYPContent(String content) {
    ArrayList result = new ArrayList();
    Matcher m = p2.matcher(content);
    Log.info(content);
    while (m.find()) {
      ArrayList line = new ArrayList();
      String no = m.group(1);
      String oz = m.group(4);
      String oh = m.group(7);
      String ok = m.group(11);

      String yz = m.group(2);
      String yh = m.group(6);
      String yk = m.group(9);
      line.add(no);
      line.add(oz);
      line.add(oh);
      line.add(ok);
      line.add(yz);
      line.add(yh);
      line.add(yk);
      result.add(line);
    }

    return result;
  }
  protected void startJetty() throws Exception {
    // Bridge Jetty logging to Android logging
    // TODO: Make configurable
    AndroidLog.__isDebugEnabled = false;
    System.setProperty("org.mortbay.log.class", "org.mortbay.log.AndroidLog");
    org.mortbay.log.Log.setLog(new AndroidLog());

    // Set jetty.home
    System.setProperty("jetty.home", IJetty.__JETTY_DIR.getAbsolutePath());

    server = newServer();

    configureConnectors();
    configureHandlers();
    configureDeployers();
    configureRealm();

    server.start();

    // TODO
    // Less than ideal solution to the problem that dalvik doesn't know about manifests of jars.
    // A as the version field is private to Server, its difficult
    // if not impossible to set it any other way. Note this means that
    // ContextHandler.SContext.getServerInfo()
    // will still return 0.0.
    HttpGenerator.setServerVersion("i-jetty " + pi.versionName);
  }
  public void fetchOYPData() {
    this.logger.info("[{}]线程开始执行,欧亚盘指数...");
    String year = DateUtils.formatDate(new Date(), "yyyy");
    String content;
    try {
      String url = "http://www.cailele.com/lottery/dcspf/spfhomeAction.php?term=";
      String pContent = HttpUtil.getContentByURL(FetchConstant.CURPERIOD_URL, false);
      Pattern p4 = Pattern.compile(FetchConstant.CUR_PERIOD);
      Matcher m = p4.matcher(pContent);
      if (m.find()) {
        String period =
            year.substring(2, year.length()) + m.group(1).substring(1, m.group(1).length());
        url = "http://www.cailele.com/lottery/dcspf/spfhomeAction.php?term=" + period;
        Log.info("==============【" + url + "】============");
      } else {
        url = FetchConstant.OYP_URL;
      }
      content = HttpUtil.getContentByURL(url, false);

      // ArrayList datas = fiterOYPContent(content);
      // BuildOYPXMLDoc(datas);
      // } catch (JDOMException e) {
      //	e.printStackTrace();
    } catch (IOException e) {
      e.printStackTrace();
    }
    this.logger.info("[{}]线程开始执行结束,欧亚盘指数...");
  }
 protected void setMessage(String message) {
   try {
     if (_formEncoded)
       setRequestContent(new ByteArrayBuffer("message=" + URLEncoder.encode(message, "utf-8")));
     else setRequestContent(new ByteArrayBuffer(message, "utf-8"));
   } catch (Exception e) {
     Log.warn(e);
   }
 }
  // clarify with Tomcat, whether this is on a per Session or SessionManager basis...
  public void setMaxInactiveInterval(int interval) {
    checkState();

    try {
      _state.setMaxInactiveInterval(interval);
    } catch (RemoteException e) {
      Log.warn("could not set MaxInactiveInterval", e);
    }
  }
Beispiel #10
0
 public void removeState(State state) {
   try {
     synchronized (_sessions) {
       _sessions.remove(state.getId());
     }
   } catch (Exception e) {
     Log.warn("could not remove session", e);
   }
 }
Beispiel #11
0
 public void storeState(State state) {
   try {
     synchronized (_sessions) {
       _sessions.put(state.getId(), state);
     }
   } catch (Exception e) {
     Log.warn("could not store session");
   }
 }
 public boolean dispatch(Runnable job) {
   try {
     executor.execute(job);
     return true;
   } catch (RejectedExecutionException e) {
     Log.warn(e);
     return false;
   }
 }
Beispiel #13
0
  /**
   * Construct a resource from a string.
   *
   * @param resource A URL or filename.
   * @param useCaches controls URLConnection caching
   * @return A Resource object.
   */
  public static Resource newResource(String resource, boolean useCaches)
      throws MalformedURLException, IOException {
    URL url = null;
    try {
      // Try to format as a URL?
      url = new URL(resource);
    } catch (MalformedURLException e) {
      if (!resource.startsWith("ftp:")
          && !resource.startsWith("file:")
          && !resource.startsWith("jar:")) {
        try {
          // It's a file.
          if (resource.startsWith("./")) resource = resource.substring(2);

          File file = new File(resource).getCanonicalFile();
          url = file.toURI().toURL();

          URLConnection connection = url.openConnection();
          connection.setUseCaches(useCaches);
          FileResource fileResource = new FileResource(url, connection, file);
          return fileResource;
        } catch (Exception e2) {
          Log.debug(Log.EXCEPTION, e2);
          throw e;
        }
      } else {
        Log.warn("Bad Resource: " + resource);
        throw e;
      }
    }

    // Make sure that any special characters stripped really are ignorable.
    String nurl = url.toString();
    if (nurl.length() > 0
        && nurl.charAt(nurl.length() - 1) != resource.charAt(resource.length() - 1)) {
      if ((nurl.charAt(nurl.length() - 1) != '/'
              || nurl.charAt(nurl.length() - 2) != resource.charAt(resource.length() - 1))
          && (resource.charAt(resource.length() - 1) != '/'
              || resource.charAt(resource.length() - 2) != nurl.charAt(nurl.length() - 1))) {
        return new BadResource(url, "Trailing special characters stripped by URL in " + resource);
      }
    }
    return newResource(url);
  }
  public void setLastAccessedTime(long time) throws IllegalStateException {
    checkState();

    try {
      _state.setLastAccessedTime(time);
    } catch (RemoteException e) {
      Log.warn("could not set LastAccessedTime", e);
      throw new IllegalStateException("problem with distribution layer");
    }
  }
  public void removeValue(String name) throws IllegalStateException {
    checkState();

    try {
      _state.removeAttribute(name, false);
    } catch (RemoteException e) {
      Log.warn("could not remove Value", e);
      throw new IllegalStateException("problem with distribution layer");
    }
  }
  public Enumeration getAttributeNames() throws IllegalStateException {
    checkState();

    try {
      return _state.getAttributeNameEnumeration();
    } catch (RemoteException e) {
      Log.warn("could not get AttributeNames", e);
      throw new IllegalStateException("problem with distribution layer");
    }
  }
  public Object getValue(String name) throws IllegalStateException {
    checkState();

    try {
      return _state.getAttribute(name);
    } catch (RemoteException e) {
      Log.warn("could not get Value", e);
      throw new IllegalStateException("problem with distribution layer");
    }
  }
  public long getCreationTime() throws IllegalStateException {
    checkState();

    try {
      return _state.getCreationTime();
    } catch (RemoteException e) {
      Log.warn("could not get CreationTime", e);
      throw new IllegalStateException("problem with distribution layer");
    }
  }
  public String[] getValueNames() throws IllegalStateException {
    checkState();

    try {
      return _state.getAttributeNameStringArray();
    } catch (RemoteException e) {
      Log.warn("could not get ValueNames", e);
      throw new IllegalStateException("problem with distribution layer");
    }
  }
 @GET
 @Produces(MediaType.WILDCARD)
 public Response redirectToWebadmin() {
   try {
     return Response.seeOther(new URI(Configurator.DEFAULT_WEB_ADMIN_PATH)).build();
   } catch (URISyntaxException e) {
     Log.warn(e.getMessage());
     return Response.serverError().build();
   }
 }
 /* ------------------------------------------------------------ */
 protected void onConnectionFailed(Throwable ex) {
   super.onConnectionFailed(ex);
   if (++_connectFailures < 5) {
     try {
       _client.send(this);
     } catch (IOException e) {
       Log.warn(e);
     }
   }
 }
Beispiel #22
0
 /* ------------------------------------------------------------ */
 protected void configure(Socket socket) throws IOException {
   try {
     socket.setTcpNoDelay(true);
     if (_maxIdleTime >= 0) socket.setSoTimeout(_maxIdleTime);
     if (_soLingerTime >= 0) socket.setSoLinger(true, _soLingerTime / 1000);
     else socket.setSoLinger(false, 0);
   } catch (Exception e) {
     Log.ignore(e);
   }
 }
  @Override
  public ApiResponse generateRequestResponse(ApiRequest request) throws Exception {
    ApiResponse response = new ApiResponse();

    // prevent spam
    UserEntry user = request.getUser();
    long businessesCreated = user.getStats().getBusinessesCreated();
    if (businessesCreated >= MAXIMUM_BUSINESS_CREATIONS) {
      Log.warn("Prevented business creation from user: "******"Spam prevention: You may not create any more businesses. Please contact us if you want to increase your quota."));
      return response;
    }

    String name = request.getParameter("name");
    String mail = request.getParameter("mail");
    boolean addQueue = request.getParameterAsBoolean("addQueue", false);

    // create the business
    BusinessEntry businessEntry = new BusinessEntry();
    businessEntry.setName(name);
    businessEntry.setMail(mail);
    Key businessKey = BusinessHelper.saveEntry(businessEntry);
    businessEntry.setKey(businessKey);

    // update user stats
    user.getStats().setBusinessesCreated(businessesCreated + 1);
    UserHelper.saveEntry(user);

    // add permission for business
    PermissionHelper.grantPermission(user, businessEntry, PermissionEntry.PERMISSION_OWN);

    if (addQueue) {
      // create a default queue
      QueueEntry queueEntry = new QueueEntry(businessKey.getId());
      queueEntry.parseFromRequest(request);

      Key queueKey = QueueHelper.saveEntry(queueEntry);
      queueEntry.setKey(queueKey);

      // add permission for queue
      PermissionHelper.grantPermission(
          request.getUser(), queueEntry, PermissionEntry.PERMISSION_OWN);

      // add the new queue to the business in order to return both as one response
      ArrayList<QueueEntry> queues = new ArrayList<QueueEntry>();
      queues.add(queueEntry);
      businessEntry.setQueues(queues);
    }

    response.setContent(businessEntry);
    return response;
  }
  public String toString() {
    StringBuilder sb = new StringBuilder();

    String showName = MediaFileAPI.GetMediaTitle(mediaFile);
    int numberOfMediaFileSegments = MediaFileAPI.GetNumberOfSegments(mediaFile);
    int segmentCount = (isFileCurrentlyRecording) ? segmentList.size() - 1 : segmentList.size();
    Log.debug("Show: " + showName);
    Log.debug("MediaFileId: " + mediaFileId);
    Log.debug("Number Of MediaFile segments: " + numberOfMediaFileSegments);
    Log.debug("Is file currently recording: " + isFileCurrentlyRecording);
    Log.debug("Number of playlist segments: " + segmentCount);

    sb.append("#EXTM3U" + LINE_TERM);
    Log.debug("#EXTM3U");
    sb.append("#EXT-X-TARGETDURATION:" + TARGET_DURATION + LINE_TERM);
    Log.debug("#EXT-X-TARGETDURATION:" + SegmentPlaylist.TARGET_DURATION);
    //        sb.append("#EXT-X-MEDIA-SEQUENCE:1" + LINE_TERM);
    //        Log.debug("#EXT-X-MEDIA-SEQUENCE:1");

    for (int i = 0; i < segmentCount; i++) {
      Segment currentSegment = segmentList.get(i);
      Segment previousSegment = (i == 0) ? null : segmentList.get(i - 1);
      Segment nextSegment = (i == segmentCount - 1) ? null : segmentList.get(i + 1);
      String str = currentSegment.toString();
      sb.append(str);

      // first or last playlist segment for each media file segment
      // printing the whole playlist makes the log harder to read
      if ((previousSegment == null)
          || (nextSegment == null)
          || (previousSegment.mediaFileSegment != currentSegment.mediaFileSegment)
          || (currentSegment.mediaFileSegment != nextSegment.mediaFileSegment)) {
        Log.debug(str);
      }
    }

    //      #EXT-X-MEDIA-SEQUENCE:<number>
    //      #EXT-X-PROGRAM-DATE-TIME:<YYYY-MM-DDThh:mm:ssZ>
    //      #EXT-X-ALLOW-CACHE:<YES|NO>
    //      #EXT-X-STREAM-INF

    if (!isFileCurrentlyRecording) {
      sb.append("#EXT-X-ENDLIST" + LINE_TERM);
      Log.debug("#EXT-X-ENDLIST");
    }
    return sb.toString();
  }
    Handshake() {
      super("handshake");
      setMessage(__HANDSHAKE);

      try {
        customize(this);
        _client.send(this);
      } catch (IOException e) {
        Log.warn(e);
      }
    }
Beispiel #26
0
  /* ------------------------------------------------------------ */
  protected boolean checkConnection() {
    super.checkConnection();
    try {
      if (_jarConnection != _connection) newConnection();
    } catch (IOException e) {
      Log.ignore(e);
      _jarConnection = null;
    }

    return _jarConnection != null;
  }
Beispiel #27
0
    /* ------------------------------------------------------------ */
    public void run() {
      Thread current = Thread.currentThread();
      String name;
      synchronized (AbstractConnector.this) {
        if (_acceptorThread == null) return;

        _acceptorThread[_acceptor] = current;
        name = _acceptorThread[_acceptor].getName();
        current.setName(name + " - Acceptor" + _acceptor + " " + AbstractConnector.this);
      }
      int old_priority = current.getPriority();

      try {
        current.setPriority(old_priority - _acceptorPriorityOffset);
        while (isRunning() && getConnection() != null) {
          try {
            accept(_acceptor);
          } catch (EofException e) {
            Log.ignore(e);
          } catch (IOException e) {
            Log.ignore(e);
          } catch (ThreadDeath e) {
            throw e;
          } catch (Throwable e) {
            Log.warn(e);
          }
        }
      } finally {
        current.setPriority(old_priority);
        current.setName(name);
        try {
          if (_acceptor == 0) close();
        } catch (IOException e) {
          Log.warn(e);
        }

        synchronized (AbstractConnector.this) {
          if (_acceptorThread != null) _acceptorThread[_acceptor] = null;
        }
      }
    }
  @Override
  public void bind(InetSocketAddress addr, int backlog) throws IOException {
    if (_started) throw new BindException("Already started");

    // check if there is already a connector listening
    Connector[] connectors = _server.getConnectors();
    if (connectors != null) throw new BindException("Server already bound");

    this._addr = addr;
    if (_executor != null && _server.getThreadPool() == null) {
      if (Log.isDebugEnabled()) Log.debug("using given Executor for server thread pool");
      _server.setThreadPool(new ThreadPoolExecutorAdapter(_executor));
    }

    SelectChannelConnector connector = new SelectChannelConnector();
    connector.setAcceptors(1);
    connector.setAcceptQueueSize(backlog);
    connector.setPort(addr.getPort());
    connector.setHost(addr.getHostName());
    _server.addConnector(connector);
  }
  public int getMaxInactiveInterval() {
    checkState();

    try {
      return _state.getMaxInactiveInterval();
    } catch (RemoteException e) {
      // Can I throw an exception of some type here - instead of
      // returning rubbish ? - TODO
      Log.warn("could not get MaxInactiveInterval", e);
      return 0;
    }
  }
 Publish() {
   super("publish");
   synchronized (_outQ) {
     if (_outQ.size() == 0) return;
     setMessages(_outQ);
     _outQ.clear();
   }
   try {
     customize(this);
     _client.send(this);
   } catch (IOException e) {
     Log.warn(e);
   }
 }