net.engio.mbassy.bus.MBassador Java Examples

@Override
public void create() {
    AssetManager assetsManager = new AssetManager(new TestFileHandleResolver());
    BasePreferencesManager preferencesManager = new BasePreferencesManager();
    PongEngine engine = new PongEngine();
    engine.addManager(new BaseAssetsManager(assetsManager, preferencesManager));
    engine.addManager(new BasePhysicsManager(new Vector2(0,0)));
    engine.addManager(new BaseGUIManager(new BitmapFont(), null, engine));
    engine.addManager(new BaseSceneManager(engine));

    game = new PongGame(engine, new EGEventBus(new MBassador()));
    game.init();
    game.pushState(new PongState(engine));

}
 

@Override
public void create() {
    engine = new ExamplesEngine();
    entitas = new Entitas();

    preferencesManager.LOG_LEVEL = LogManager.LOG_DEBUG;
    AssetManager assetsManager = new AssetManager(new TestFileHandleResolver());
    engine.addManager(new AssetsManagerGDX(assetsManager, preferencesManager));
    engine.addManager(new PhysicsManagerGDX(new Vector2(0,-9.8f)));
    engine.addManager(new GUIManagerGDX(new ScreenViewport(),new BitmapFont(), engine));
    engine.addManager(new SceneManagerGDX(engine, entitas));
    engine.addManager(new LogManagerGDX(preferencesManager));
    engine.addManager(new InputManagerGDX(entitas, engine));
    engine.addManager(preferencesManager);

    game = new ExamplesGame(engine, new EventBusGDX(new MBassador()));
    game.init();
    game.pushState(new PlatformExampleState(engine, entitas));

}
 

public RollupService(MBassador<DistheneEvent> bus, DistheneConfiguration distheneConfiguration, List<Rollup> rollups) {
    this.distheneConfiguration = distheneConfiguration;
    this.rollups = rollups;
    this.bus = bus;
    bus.subscribe(this);

    for(Rollup rollup : rollups) {
        if (maxRollup == null || maxRollup.getRollup() < rollup.getRollup()) {
            maxRollup = rollup;
        }
    }

    scheduler.scheduleAtFixedRate(new Runnable() {
        @Override
        public void run() {
            flush();
        }
    }, 60 - ((System.currentTimeMillis() / 1000L) % 60), RATE, TimeUnit.SECONDS);
}
 

public StreamingContainerManager(LogicalPlan dag, boolean enableEventRecording, Clock clock)
{
  this.clock = clock;
  this.vars = new FinalVars(dag, clock.getTime());
  poolExecutor = Executors.newFixedThreadPool(4);
  // setup prior to plan creation for event recording
  if (enableEventRecording) {
    this.eventBus = new MBassador<>(BusConfiguration.Default(1, 1, 1));
  }
  this.plan = new PhysicalPlan(dag, this);
  this.journal = new Journal(this);
  init(enableEventRecording);
}
 

/**
 * Creates a new {@link ClientModel} backed by the specified
 * {@link ClientManager}.
 */
public ClientModel(ClientManager clientManager) {
    this.clientManager = Objects.requireNonNull(clientManager, "clientManager");
    this.bus = new MBassador<Object>(new BusConfiguration()
            .addFeature(Feature.SyncPubSub.Default())
            .addFeature(Feature.AsynchronousHandlerInvocation.Default())
            .addFeature(Feature.AsynchronousMessageDispatch.Default()));
}
 

/**
 * Creates a new {@link TaskModel} backed by the specified
 * {@link TaskManager}.
 */
public TaskModel(TaskManager taskManager) {
    this.taskManager = Objects.requireNonNull(taskManager, "taskManager");
    this.bus = new MBassador<Object>(new BusConfiguration()
            .addFeature(Feature.SyncPubSub.Default())
            .addFeature(Feature.AsynchronousHandlerInvocation.Default())
            .addFeature(Feature.AsynchronousMessageDispatch.Default()));
}
 

public MBassador<Map<String, Object>> getEventBus(String topic) {
    MBassador<Map<String, Object>> eventBus = eventBusMap.get(topic);
    if(eventBus == null) {
        eventBus = new MBassador<Map<String, Object>>();
        eventBusMap.put(topic, eventBus);
    }
    return eventBus;
}
 

protected void publishEvent(Map<String, Object> eventMap) throws Exception {
    // get class name
    //System.out.println(this.getClass().getPackage());
    //System.out.println(this.getClass().getName());
    // check if publisher is enabled.
    Map map = getRuleByRuleClass(this.getClass().getName());
    Object isPublisher = map.get("isPublisher");
    if(isPublisher != null && (boolean)isPublisher) {
        //System.out.println("isPublisher");
        MBassador<Map<String, Object>> eventBus = ServiceLocator.getInstance().getEventBus((String)eventMap.get("category"));
        eventBus.publish(eventMap);
    }
}
 

public WriterThread(String name, MBassador<DistheneEvent> bus, Session session, PreparedStatement statement, Queue<Metric> metrics, Executor executor) {
    super(name);
    this.bus = bus;
    this.session = session;
    this.statement = statement;
    this.metrics = metrics;
    this.executor = executor;
}
 

public StatsService(MBassador<DistheneEvent> bus, StatsConfiguration statsConfiguration, Rollup rollup) {
    this.statsConfiguration = statsConfiguration;
    this.bus = bus;
    this.rollup = rollup;
    bus.subscribe(this);

    scheduler.scheduleAtFixedRate(new Runnable() {
        @Override
        public void run() {
            flush();
        }
    }, 60 - ((System.currentTimeMillis() / 1000L) % 60), statsConfiguration.getInterval(), TimeUnit.SECONDS);

}
 

public IndexService(IndexConfiguration indexConfiguration, MBassador<DistheneEvent> bus) {
    this.indexConfiguration = indexConfiguration;

    bus.subscribe(this);

    Settings settings = ImmutableSettings.settingsBuilder()
            .put("cluster.name", indexConfiguration.getName())
            .build();
    client = new TransportClient(settings);
    for (String node : indexConfiguration.getCluster()) {
        client.addTransportAddress(new InetSocketTransportAddress(node, indexConfiguration.getPort()));
    }

    indexThread = new IndexThread(
            "distheneIndexThread",
            client,
            metrics,
            indexConfiguration.getIndex(),
            indexConfiguration.getType(),
            indexConfiguration.getBulk().getActions(),
            indexConfiguration.getBulk().getInterval()
    );

    indexThread.start();

    if (indexConfiguration.isCache()) {
        scheduler.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                expireCache();
            }
        }, indexConfiguration.getExpire(), indexConfiguration.getExpire(), TimeUnit.SECONDS);
    }
}
 

public AggregateService(MBassador<DistheneEvent> bus, DistheneConfiguration distheneConfiguration) {
    this.distheneConfiguration = distheneConfiguration;
    this.baseRollup = distheneConfiguration.getCarbon().getBaseRollup();
    this.bus = bus;
    bus.subscribe(this);

    scheduler.scheduleAtFixedRate(new Runnable() {
        @Override
        public void run() {
            flush();
        }
    }, 60 - ((System.currentTimeMillis() / 1000L) % 60), RATE, TimeUnit.SECONDS);
}
 

public SumService(MBassador<DistheneEvent> bus, DistheneConfiguration distheneConfiguration, AggregationConfiguration aggregationConfiguration, BlacklistService blacklistService) {
    this.bus = bus;
    this.distheneConfiguration = distheneConfiguration;
    this.aggregationConfiguration = aggregationConfiguration;
    this.blacklistService = blacklistService;
    bus.subscribe(this);


    scheduler.scheduleAtFixedRate(new Runnable() {
        @Override
        public void run() {
            flush();
        }
    }, 60 - ((System.currentTimeMillis() / 1000L) % 60), RATE, TimeUnit.SECONDS);
}
 

private StreamingContainerManager(CheckpointState checkpointedState, boolean enableEventRecording)
{
  this.vars = checkpointedState.finals;
  this.clock = new SystemClock();
  poolExecutor = Executors.newFixedThreadPool(4);
  this.plan = checkpointedState.physicalPlan;
  this.eventBus = new MBassador<>(BusConfiguration.Default(1, 1, 1));
  this.journal = new Journal(this);
  init(enableEventRecording);
}
 

public StreamingContainerManager(LogicalPlan dag, boolean enableEventRecording, Clock clock)
{
  this.clock = clock;
  this.vars = new FinalVars(dag, clock.getTime());
  poolExecutor = Executors.newFixedThreadPool(4);
  // setup prior to plan creation for event recording
  if (enableEventRecording) {
    this.eventBus = new MBassador<>(BusConfiguration.Default(1, 1, 1));
  }
  this.plan = new PhysicalPlan(dag, this);
  this.journal = new Journal(this);
  init(enableEventRecording);
}
 

protected StreamingContainer(String containerId, StreamingContainerUmbilicalProtocol umbilical)
{
  this.jvmName = java.lang.management.ManagementFactory.getRuntimeMXBean().getName();
  this.components = new HashSet<>();
  this.eventBus = new MBassador<>(BusConfiguration.Default(1, 1, 1));
  this.singletons = new HashMap<>();
  this.nodeRequests = new ArrayList<>();

  logger.debug("instantiated StramChild {}", containerId);
  this.umbilical = umbilical;
  this.containerId = containerId;
}
 

private StreamingContainerManager(CheckpointState checkpointedState, boolean enableEventRecording)
{
  this.vars = checkpointedState.finals;
  this.clock = new SystemClock();
  poolExecutor = Executors.newFixedThreadPool(4);
  this.plan = checkpointedState.physicalPlan;
  this.eventBus = new MBassador<>(BusConfiguration.Default(1, 1, 1));
  this.journal = new Journal(this);
  init(enableEventRecording);
}
 

protected StreamingContainer(String containerId, StreamingContainerUmbilicalProtocol umbilical)
{
  this.jvmName = java.lang.management.ManagementFactory.getRuntimeMXBean().getName();
  this.components = new HashSet<>();
  this.eventBus = new MBassador<>(BusConfiguration.Default(1, 1, 1));
  this.singletons = new HashMap<>();
  this.nodeRequests = new ArrayList<>();

  logger.debug("instantiated StramChild {}", containerId);
  this.umbilical = umbilical;
  this.containerId = containerId;
}
 

public CarbonServer(DistheneConfiguration configuration, MBassador<DistheneEvent> bus) {
    this.bus = bus;
    this.configuration = configuration;
}
 

public CarbonServerHandler(MBassador<DistheneEvent> bus, Rollup rollup) {
    this.bus = bus;
    this.rollup = rollup;
}
 

public MetricService(MBassador<DistheneEvent> bus, BlacklistService blacklistService, DistheneConfiguration distheneConfiguration) {
    this.bus = bus;
    this.blacklistService = blacklistService;
    this.distheneConfiguration = distheneConfiguration;
    bus.subscribe(this);
}
 

public SingleWriterThread(String name, MBassador<DistheneEvent> bus, Session session, PreparedStatement statement, Queue<Metric> metrics, Executor executor) {
    super(name, bus, session, statement, metrics, executor);
}
 

BatchWriterThread(String name, MBassador<DistheneEvent> bus, Session session, PreparedStatement statement, Queue<Metric> metrics, Executor executor, int batchSize) {
    super(name, bus, session, statement, metrics, executor);
    this.batchSize = batchSize;
}
 

@Override
    public void create() {
        AssetManager assetsManager = new AssetManager(new TestFileHandleResolver());
        BasePreferencesManager preferencesManager = new BasePreferencesManager();
        MatchOneEngine engine = new MatchOneEngine();
        engine.addManager(new BaseAssetsManager(assetsManager, preferencesManager));
//        new Collections(new CollectionsFactory() {
//            @Override
//            public <T> List<T> createList(Class<T> clazz) {
//                if (clazz.equals(Integer.class))
//                    return (List<T>) new IntArrayList();
//                else
//                    return new ObjectArrayList();
//            }
//
//            @Override
//            public <T> Set createSet(Class<T> clazz) {
//                if (clazz.equals(Integer.class))
//                    return new IntArraySet();
//                else
//                    return new ObjectOpenHashSet();
//        }
//
//            @Override
//            public <K, V> Map createMap(Class<K> keyClazz, Class<V> valueClazz) {
//                return new Object2ObjectArrayMap();
//            }
//
//
//        });

        new EntitasCollections(new CollectionsFactories(){});

        MBassador bus = new MBassador(new IPublicationErrorHandler() {
            @Override
            public void handleError(PublicationError error) {
                Gdx.app.error("EBUS ERROR: ", error.toString());
            }
        });


        game = new MatchOneGame(engine, new EGEventBus(bus));
        game.init();
        game.pushState(new MatchOneState(engine));
    }
 

public EventBusGDX(MBassador ebus) {
    this.ebus = ebus;
}
 

@Before
public void prepareTests() {

    dispatcher = new MBassador<String>(this);
    dispatcher.subscribe(this);
}