Java Topic类代码示例

import rice.p2p.scribe.Topic; //导入依赖的package包/类
@Before
public void before() throws Exception {
    scribeClient = mock(ScribeMultiClient.class);
    topic = mock(Topic.class);
    id = mock(Id.class);
    topicId = mock(Id.class);
    endpoint = mock(Endpoint.class);
    scribeContent = mock(KoalaScribeContent.class);
    applicationContext = mock(ApplicationContext.class);
    wrappedScribeContentMessage = new WrappedScribeContentMessage(mock(NodeHandle.class), topic, WrappedScribeContentMessageType.ANYCAST, EntityMethod.UPDATE, "json", "transaction-id");

    koalaIdFactory = mock(KoalaIdFactory.class);
    when(koalaIdFactory.buildIdFromToString(TOPIC_ID)).thenReturn(topicId);

    scribe = spy(new KoalaScribeImpl(setupPastryNode(), applicationContext));
    scribe.setKoalaIdFactory(koalaIdFactory);

    messageDeserializer = scribe.getEndpoint().getDeserializer();
}
 

import rice.p2p.scribe.Topic; //导入依赖的package包/类
/**
 * Internal Pi method that converts pastry Scribe messages to PubSubMessageContext messages.
 */
@Override
@Deprecated
public final void deliver(Topic topic, ScribeContent content) {
    LOG.debug(String.format("deliver(Topic - %s, ScribeContent - %s)", topic, content));
    if (content instanceof KoalaScribeContent) {
        KoalaScribeContent koalaScribeContent = (KoalaScribeContent) content;
        String transactionUID = koalaScribeContent.getTransactionUID();
        EntityMethod entityMethod = koalaScribeContent.getEntityMethod();
        MDCHelper.putTransactionUID(transactionUID);

        long startTime = ContinuationUtils.logStartOfContinuation(ContinuationUtils.SCRIBE_DELIVER, transactionUID);

        try {
            PiEntity scribeData = getPiEntityFromJson(koalaScribeContent.getJsonData());
            PubSubMessageContext pubSubMessageContext = newPubSubMessageContext(topic, koalaScribeContent.getSourceNodeHandle(), transactionUID);
            deliver(pubSubMessageContext, entityMethod, scribeData);
        } catch (Throwable t) {
            LOG.error(t.getMessage(), t);
            throw new RuntimeException(t);
        } finally {
            MDCHelper.clearTransactionUID();
            ContinuationUtils.logEndOfContinuation(ContinuationUtils.SCRIBE_DELIVER, transactionUID, startTime);
        }
    }
}
 

import rice.p2p.scribe.Topic; //导入依赖的package包/类
@Test
public void testOnApplicationStarting() {
    // setup
    setupTopics();
    Topic topic = mock(Topic.class);
    when(aScribe.subscribeToTopic(isA(String.class), isA(ScribeMultiClient.class))).thenReturn(topic);

    when(koalaIdUtils.isIdClosestToMe(eq(nodeIdFull), eq(leafNodeHandles), isA(Id.class), eq(NodeScope.AVAILABILITY_ZONE))).thenReturn(false).thenReturn(true);

    // act
    volumeManagerApplication.onApplicationStarting();

    // assert
    assertTrue(this.volumeManagerApplication.getSubscribedTopics().contains(createVolumeTopic));
    assertTrue(this.volumeManagerApplication.getSubscribedTopics().contains(deleteVolumeTopic));
    assertTrue(this.volumeManagerApplication.getSubscribedTopics().contains(detachVolumeTopic));
    assertTrue(this.volumeManagerApplication.getSubscribedTopics().contains(attachVolumeTopic));
    assertTrue(this.volumeManagerApplication.getSubscribedTopics().contains(createSnapshotTopic));
    assertTrue(this.volumeManagerApplication.getSubscribedTopics().contains(deleteSnapshotTopic));

    verify(volumeManagerQueueManager).createVolumeApplicationWatchers(nodeIdFull);
}
 

import rice.p2p.scribe.Topic; //导入依赖的package包/类
/**
 * Called when a message is received for a topic this node has subscribed.
 * <p>
 * This application only uses one topic to broadcast reset notifications.
 * When receiving a reset notification, reset the current value to the
 * original value and set the weight to 1.
 */
@Override
public void deliver(Topic topic, ScribeContent content)
{
	if (trace)
	{
		log("deliver (" + topic + "," + content + ")");
	}

	if (content instanceof ResetNotification)
	{
		this.value = trueValue;
		this.valueBuffer = trueValue;
		this.weight = 1.;
		this.weightBuffer = 1.;
	}
}
 

import rice.p2p.scribe.Topic; //导入依赖的package包/类
@Test
public void shouldAllowConstructionWithTopicEntityAndTransactionUID() {
    // act
    pubSubMessageContext = new PubSubMessageContext(handlingApplication, topicEntity, "aa");

    // assert
    assertEquals(new Topic(tId), pubSubMessageContext.getTopic());
    assertEquals("aa", pubSubMessageContext.getTransactionUID());
}
 

import rice.p2p.scribe.Topic; //导入依赖的package包/类
@Override
public final void childAdded(Topic topic, NodeHandle child) {
    long startTime = ContinuationUtils.logStartOfContinuation(ContinuationUtils.SCRIBE_CHILD_ADDED, null);

    try {
        LOG.debug(String.format("childAdded(%s, %s)", topic, child));
    } finally {
        ContinuationUtils.logEndOfContinuation(ContinuationUtils.SCRIBE_CHILD_ADDED, null, startTime);
    }
}
 

import rice.p2p.scribe.Topic; //导入依赖的package包/类
@Test
public void testFailedTopic() {
    // setup
    ArrayList<Topic> topics = new ArrayList<Topic>();
    koalaPastryScribeApplication.subscribe(idFactory.convertToPId(topic.getId()), koalaPastryScribeApplication);
    topics.add(topic);

    // act
    koalaPastryScribeApplication.subscribeFailed(topics);

    // assert
    assertEquals(0, koalaPastryScribeApplication.getSubscribedTopics().size());
}
 

import rice.p2p.scribe.Topic; //导入依赖的package包/类
@Override
public final void subscribeFailed(Topic topic) {
    long startTime = ContinuationUtils.logStartOfContinuation(ContinuationUtils.SCRIBE_SUBSCRIBE_FAILED, null);

    try {
        LOG.debug(String.format(SUBSCRIBE_FAILED_S, topic));
        if (topic != null) {
            subscribedTopics.remove(topic);
        }
    } finally {
        ContinuationUtils.logEndOfContinuation(ContinuationUtils.SCRIBE_SUBSCRIBE_FAILED, null, startTime);
    }
}
 

import rice.p2p.scribe.Topic; //导入依赖的package包/类
public WrappedScribeContentMessage(NodeHandle sourceHandle, Topic aTopic, WrappedScribeContentMessageType aWrappedScribeContentMessageType, EntityMethod anEntityMethod, String aJsonData, String aTransactionUID) {
    super(sourceHandle, aTopic);
    wrappedScribeContentMessageType = aWrappedScribeContentMessageType;
    entityMethod = anEntityMethod;
    jsonData = aJsonData;
    transactionUID = aTransactionUID;
}
 

import rice.p2p.scribe.Topic; //导入依赖的package包/类
@Test
public void constructorsShouldBeEquivalent() {
    // act
    PubSubMessageContext scopedEntityContext = new PubSubMessageContext(handlingApplication, topicEntity, TRANSACTION_ID);
    PubSubMessageContext topicContext = new PubSubMessageContext(handlingApplication, new Topic(tId), handlingApplication.getNodeHandle(), TRANSACTION_ID);

    // assert
    assertEquals(scopedEntityContext, topicContext);
}
 

import rice.p2p.scribe.Topic; //导入依赖的package包/类
/**
 * The constructor for this scribe client.  It will construct the ScribeApplication.
 * 
 * @param node the PastryNode
 */
public MyScribeClient(Node node) {
  // you should recognize this from lesson 3
  this.endpoint = node.buildEndpoint(this, "myinstance");

  // construct Scribe
  myScribe = new ScribeImpl(node,"myScribeInstance");

  // construct the topic
  myTopic = new Topic(new PastryIdFactory(node.getEnvironment()), "example topic");
  System.out.println("myTopic = "+myTopic);
  
  // now we can receive messages
  endpoint.register();
}
 

import rice.p2p.scribe.Topic; //导入依赖的package包/类
/**
 * Called whenever we receive a published message.
 */
public void deliver(Topic topic, ScribeContent content) {
  System.out.println("MyScribeClient.deliver("+topic+","+content+")");
  if (((MyScribeContent)content).from == null) {
    new Exception("Stack Trace").printStackTrace();
  }
}
 

import rice.p2p.scribe.Topic; //导入依赖的package包/类
@Test
public void testCreateTopic() {
    // setup
    PId topicPId = mock(PId.class);
    when(topicPId.forLocalScope(eq(NodeScope.REGION))).thenReturn(topicPId);
    when(koalaIdFactory.buildPId(DUMMY_NETWORK)).thenReturn(topicPId);
    when(koalaIdFactory.buildId(topicPId)).thenReturn(id);

    // act
    Topic result = scribe.createTopic(DUMMY_NETWORK);

    // assert
    assertThat(result.getId(), equalTo(id));
}
 

import rice.p2p.scribe.Topic; //导入依赖的package包/类
@Override
public final void subscribeSuccess(Collection<Topic> topics) {
    long startTime = ContinuationUtils.logStartOfContinuation(ContinuationUtils.SCRIBE_SUBSCRIBE_SUCCESS, null);

    try {
        LOG.debug(String.format("subscribeSuccess(%s)", topics));
        handleSubscribeSuccess(topics);
    } finally {
        ContinuationUtils.logEndOfContinuation(ContinuationUtils.SCRIBE_SUBSCRIBE_SUCCESS, null, startTime);
    }
}
 

import rice.p2p.scribe.Topic; //导入依赖的package包/类
public Topic subscribeToTopic(String topicName, ScribeMultiClient scribeClient) {
    LOG.debug(String.format("subscribeToTopic(%s, %s)", topicName, scribeClient));

    Topic topic = createTopic(topicName);
    subscribe(topic, scribeClient);
    return topic;
}