@Test
  public void testMessage() throws Exception {
    failed = false;

    speaker1.send("MyUDPTopic", new MyMessage(MESSAGE + "1"));
    MyMessage m = queue.poll(2000l, TimeUnit.MILLISECONDS);
    assertNotNull(m);
    assertEquals(m.getMessage(), MESSAGE + "1");

    if (failed) {
      fail();
    }

    speaker1.send("BadTopic", new MyMessage(MESSAGE + "2"));
    m = queue.poll(500l, TimeUnit.MILLISECONDS);
    assertNull(m);

    queue.clear();

    speaker2.send("MyUDPTopic", new MyMessage(MESSAGE + "1"));
    m = queue.poll(2000l, TimeUnit.MILLISECONDS);
    assertNotNull(m);
    assertEquals(m.getMessage(), MESSAGE + "1");

    if (failed) {
      fail();
    }

    speaker2.send("BadTopic", new MyMessage(MESSAGE + "2"));
    m = queue.poll(500l, TimeUnit.MILLISECONDS);
    assertNull(m);

    queue.clear();
  }
Exemple #2
0
  public static void main(String[] args) throws Exception {
    MyMessage src1 = new MyMessage();
    src1.name = "msgpack";
    src1.version = 0.6;
    MyMessage src2 = new MyMessage();
    src2.name = "muga";
    src2.version = 10.0;
    MyMessage src3 = new MyMessage();
    src3.name = "frsyukik";
    src3.version = 1.0;

    MessagePack msgpack = new MessagePack();
    //
    // Serialize
    //
    ByteArrayOutputStream out = new ByteArrayOutputStream();
    Packer packer = msgpack.createPacker(out);
    packer.write(src1);
    packer.write(src2);
    packer.write(src3);
    byte[] bytes = out.toByteArray();

    //
    // Deserialize
    //
    ByteArrayInputStream in = new ByteArrayInputStream(bytes);
    Unpacker unpacker = msgpack.createUnpacker(in);
    MyMessage dst1 = unpacker.read(MyMessage.class);
    MyMessage dst2 = unpacker.read(MyMessage.class);
    MyMessage dst3 = unpacker.read(MyMessage.class);
  }
  public void play(LinkedBlockingQueue<MyMessage> input) {
    // this.input = input;

    // System.out.println(Thread.currentThread().getName());

    while (!done) {
      MyMessage message = null;
      try {
        message = input.poll(1, TimeUnit.MICROSECONDS);
      } catch (InterruptedException e) {
        e.printStackTrace();
      }

      // check timing
      // long time = System.currentTimeMillis() % 1000;

      if (message != null) {
        // System.out.println("GOT MESSAGE");
        // check message type
        switch (message.getType()) {
          case TIME_UPDATE:
            songTime = (double) message.getData1();

            sendIfReady();
            break;
          default:
            System.err.println(message.toString() + " not implemented yet in output part!");
            break;
        }
        // System.out.println("GOT MESSAGE");
        // double partTime = (Double) message.getData1();
        // double nextTime = (Double) message.getData1();
        // int partChannel = message.getChannel();
        //
        // currentInputTimes[partChannel] = partTime;
        // nextInputTimes[partChannel] = nextTime;
        //
        // // check if we should listen to this part for now
        // double timeDiff = nextTime - partTime;
        // if (timeDiff > 0 && timeDiff > 5) {
        // // 5 for temporary fixing with changing types
        // listen[partChannel] = false;
        // }

      }
    }
  }
  private MyMessage getMessage() throws Exception {
    int dataRecieved = 0;
    String m = new String();
    String t;

    // FIXME needs to get multiple packets and messages
    // System.out.println("RT: Now waiting for message data");

    while (dataRecieved < totalDataSize) {
      // Get message data
      response = new byte[65000];
      DatagramPacket packet = new DatagramPacket(response, response.length);
      socket.receive(packet);
      Packet p = new Packet(packet.getData());
      // System.out.println("RT: Got message with seqnum: "+p.getSeqNum());

      // If we have a handshake packet something broke
      if (p.isHandshake()) {
        return null;
      }

      // If next in-order packet grab data and is not corrupt
      // XXX
      if (p.getSeqNum() == seqNum + 1 && p.checkChecksum()) {
        // Get the message ( part? )
        // System.out.println("RT: Is correct seqnum");
        t = p.getMessages().get(0).getMessageContents();
        // System.out.println("RT: Got message packet: " + t);
        m += t;

        // Send ack
        sendAck(p, packet);

        // Increment counters
        dataRecieved += t.length();
        seqNum++;
      } else {
        System.out.println("RT: Is NOT correct seqnum");
      }
    }
    MyMessage result = new MyMessage();
    result.setMessageContents(m);
    return result;
  }
    @Override
    public void receive(MyMessage message) {
      LOG.info("Got a message " + message.getMessage());

      boolean success = queue.offer(message);

      if (!success) {
        failed = true;
      }
    }
Exemple #6
0
  public static MyMessage Post(String url, String data) {
    CobubLog.d(UmsConstants.LOG_TAG, NetworkUtil.class, "URL = " + url);
    CobubLog.d(
        UmsConstants.LOG_TAG,
        NetworkUtil.class,
        "LENGTH:" + data.length() + " *Data = " + data + "*");

    if (!hasInitSSL && UmsConstants.SDK_SECURITY_LEVEL.equals("2")) {
      initSSL();
      hasInitSSL = true;
    }

    BasicHttpParams httpParams = new BasicHttpParams();
    HttpConnectionParams.setConnectionTimeout(httpParams, REQUEST_TIMEOUT);
    HttpConnectionParams.setSoTimeout(httpParams, SO_TIMEOUT);
    DefaultHttpClient httpclient = null;

    /*SDK会运行在如下两种环境中:
     * 1,CPOS:需要进行双向ssl校验;SDK_SSL=true;此时还要验证dn(如果不想验dn,设置SDK_HTTPS_DN为none)
     * 2,一般移动设备,是用HTTPS正常发送即可,也能接受非标准证书的https服务端
     * 3,测试:使用http
     */
    if (UmsConstants.SDK_SECURITY_LEVEL.equals("2")) {
      httpclient = new DefaultHttpClient(httpParams);
      // cpos with dn check
      if (!UmsConstants.SDK_HTTPS_DN.equals("none")) {
        SSLSocketFactory mysf = null;
        try {
          mysf = new CposSSLSocketFactory();
          if (serverUrl == null) {
            serverUrl = new URL(url);
            serverPort =
                ((serverUrl.getPort() == -1) ? serverUrl.getDefaultPort() : serverUrl.getPort());
          }

          httpclient
              .getConnectionManager()
              .getSchemeRegistry()
              .register(new Scheme(serverUrl.getProtocol(), mysf, serverPort));

        } catch (Exception e) {
          CobubLog.d(UmsConstants.LOG_TAG, NetworkUtil.class, e.toString());
        }
      }
    } else if (UmsConstants.SDK_SECURITY_LEVEL.equals("1")
        && url.toLowerCase().startsWith("https")) {
      // for https with company cert
      if (serverPort < 0) {
        serverPort = getPort();
      }
      CobubLog.d(UmsConstants.LOG_TAG, NetworkUtil.class, "InitSSL port is:" + serverPort);
      SchemeRegistry schReg = new SchemeRegistry();
      schReg.register(new Scheme("https", SSLCustomSocketFactory.getSocketFactory(), serverPort));

      ClientConnectionManager connMgr = new ThreadSafeClientConnManager(httpParams, schReg);
      httpclient = new DefaultHttpClient(connMgr, httpParams);
    } else {
      httpclient = new DefaultHttpClient(httpParams);
    }
    processCookieRejected(httpclient);

    MyMessage message = new MyMessage();
    try {
      HttpPost httppost = new HttpPost(url);

      StringEntity se = new StringEntity("content=" + URLEncoder.encode(data), HTTP.UTF_8);
      se.setContentType("application/x-www-form-urlencoded");
      httppost.setEntity(se);

      HttpResponse response = httpclient.execute(httppost);
      CobubLog.d(
          UmsConstants.LOG_TAG,
          NetworkUtil.class,
          "Status code=" + response.getStatusLine().getStatusCode());

      String returnXML = EntityUtils.toString(response.getEntity());
      int status = response.getStatusLine().getStatusCode();
      String returnContent = URLDecoder.decode(returnXML, "UTF-8");
      CobubLog.d(UmsConstants.LOG_TAG, NetworkUtil.class, "returnString = " + returnContent);
      // TODO:只要服務端有返回200ok并且返回的是json字符串即可认为发送成功;因为如果发送的数据不完整服务端会返回flag<0;
      // 这部分数据按照flag来判断会导致错误数据始终保存在本地
      switch (status) {
        case 200:
          message.setSuccess(isJson(returnContent));
          message.setMsg(returnContent);
          break;
        default:
          Log.e("error", status + returnContent);
          message.setSuccess(false);
          message.setMsg(returnContent);
          break;
      }
    } catch (Exception e) {
      message.setSuccess(false);
      message.setMsg(e.toString());
    }
    return message;
  }
  public FIFOBroadcastClient(
      boolean isBroadcaster,
      String host,
      int thisport,
      int startport,
      int endport,
      String message,
      int numMessages) {
    this.port = thisport;
    this.isBroadcaster = isBroadcaster;
    // System.out.println("FIFO BROADCAST CLIENT");
    // Initialize
    rb = new MyFIFOReliableBroadcast();
    Process p = new Process(host, thisport);
    rb.init(p);
    rb.rblisten(this); // Give MRB our callback method

    for (int i = startport; i <= endport; i++) {
      if (i != thisport) {
        rb.addProcess(new Process(host, i));
      }
    }

    /*
    while(true){

    	Console console = System.console();
    	String input = console.readLine("Message to broadcast: ");

    	//XXX
    	System.out.println("Sending: " + input );
    	MyMessage m = new MyMessage();
    	m.setMessageContents( input );
    	rb.rbroadcast(m);


    }
    */

    if (isBroadcaster) {

      MyMessage m1 = new MyMessage();
      MyMessage m2 = new MyMessage();
      m1.setMessageContents("Message 1");
      m2.setMessageContents("Message 2");
      m1.setMessageNumber(0);
      m2.setMessageNumber(1);
      m2.makesObsolete(0);
      rb.rbroadcast(m1);

      try {
        // Thread.currentThread().sleep(5000);
      } catch (Exception e) {
      }
      System.out.println("Broadcasting 2");
      rb.rbroadcast(m2);
    }
    // if(this.isBroadcaster){
    // MyMessage m = new MyMessage();
    // m.setMessageContents(message);
    // for(int j = 0; j < numMessages; j++){
    // rb.rbroadcast(m);
    // }
    // }

  }