NewRepositoryEventAdapter

package org.kie.uberfire.social.activities.adapters;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import javax.enterprise.context.ApplicationScoped;
import javax.inject.Inject;

import org.kie.uberfire.social.activities.model.ExtendedTypes;
import org.kie.uberfire.social.activities.model.SocialActivitiesEvent;
import org.kie.uberfire.social.activities.model.SocialEventType;
import org.kie.uberfire.social.activities.model.SocialUser;
import org.kie.uberfire.social.activities.repository.SocialUserRepository;
import org.kie.uberfire.social.activities.service.SocialAdapter;
import org.kie.uberfire.social.activities.service.SocialCommandTypeFilter;

@ApplicationScoped
public class NewRepositoryEventAdapter implements SocialAdapter<NewRepositoryEvent> {

    @Inject
    SocialUserRepository socialUserRepository;

    @Override
    public Class<NewRepositoryEvent> eventToIntercept() {
        return NewRepositoryEvent.class;
    }

    @Override
    public SocialEventType socialEventType() {
        return ExtendedTypes.NEW_REPOSITORY_EVENT;
    }

    @Override
    public boolean shouldInterceptThisEvent( Object event ) {
        if ( event.getClass().getSimpleName().equals( eventToIntercept().getSimpleName() ) ) {
            return true;
        }
        return false;
    }

    @Override
    public SocialActivitiesEvent toSocial( Object object ) {
        NewRepositoryEvent event = (NewRepositoryEvent) object;
        String aditionalInfo = "created repository " + event.getNewRepository().getAlias();
        return new SocialActivitiesEvent( socialUserRepository.systemUser(), ExtendedTypes.NEW_REPOSITORY_EVENT, new Date(), aditionalInfo );
    }

    @Override
    public List<SocialCommandTypeFilter> getTimelineFilters() {
        ArrayList<SocialCommandTypeFilter> socialCommandTypeFilters = new ArrayList<SocialCommandTypeFilter>();
        socialCommandTypeFilters.add( new SocialCommandTypeFilter() {
            @Override
            public List<SocialActivitiesEvent> execute( String parameter,
                                                        List<SocialActivitiesEvent> events ) {
                List<SocialActivitiesEvent> newList = new ArrayList<SocialActivitiesEvent>();
                Integer maxResults = new Integer( parameter );
                for ( int i = 0; i < maxResults; i++ ) {
                    newList.add( events.get( i ) );
                }
                return newList;
            }

            @Override
            public String getCommandName() {
                return "max-results";
            }
        } );

        socialCommandTypeFilters.add( new SocialCommandTypeFilter() {
            @Override
            public List<SocialActivitiesEvent> execute( String parameter,
                                                        List<SocialActivitiesEvent> events ) {
                List<SocialActivitiesEvent> newList = new ArrayList<SocialActivitiesEvent>();
                for ( SocialActivitiesEvent event : events ) {
                    String name = event.getSocialUser().getName();
                    SocialUser socialUser = new SocialUser( name + " - filtered" );
                    SocialActivitiesEvent socialEvent = new SocialActivitiesEvent( socialUser, event.getType(), new Date() );
                    newList.add( socialEvent );
                }
                return newList;
            }

            @Override
            public String getCommandName() {
                return "another-filter";
            }
        } );
        return socialCommandTypeFilters;
    }

    @Override
    public List<String> getTimelineFiltersNames() {
        List<String> names = new ArrayList<String>();
        names.add( "max-results" );
        names.add( "another-filter" );
        return names;
    }
}

SocialStressTest.java

package org.kie.uberfire.social.activities.stress;

import java.util.Collection;
import java.util.Date;
import java.util.List;
import java.util.Map;
import javax.enterprise.context.ApplicationScoped;
import javax.enterprise.event.Event;
import javax.inject.Inject;

import org.guvnor.structure.repositories.NewRepositoryEvent;
import org.guvnor.structure.repositories.PublicURI;
import org.guvnor.structure.repositories.Repository;
import org.jboss.errai.bus.server.annotations.Service;
import org.uberfire.backend.vfs.Path;
import org.kie.uberfire.social.activities.model.FollowSocialUserEvent;
import org.kie.uberfire.social.activities.model.SocialUser;
import org.kie.uberfire.social.activities.service.StressTestAPI;

@ApplicationScoped
@Service
public class SocialStressTest implements StressTestAPI {

    @Inject
    Event<FollowSocialUserEvent> followSocialUserEventEvent;

    @Inject
    Event<NewRepositoryEvent> newRepositoryEvent;

    @Override
    public int stress( int numberOf10Events, int totalSleepBetweenEvents ) {
        //sed 's/[^$]//g' 1 | tr -d '\012' | wc -c
        int numberOfEvents = 0;

        Date start = new Date();
        System.out.println( "Start: " + start );
        for ( int i = 0; i <= 100; i++ ) {
            numberOfEvents = numberOfEvents + generate10EventsNTimesAndWaitNSecond( numberOf10Events, -1 );
        }
        Date finish = new Date();
        long delta = finish.getTime() - start.getTime();
        System.out.println( "/Finish, total time in ms: " + delta );
        System.out.println( "Number of events " + numberOfEvents );

        return numberOfEvents;
    }

    private int generate10EventsNTimesAndWaitNSecond( int numberOfEvents,
                                                      int sleep ) {

        int events = 0;
        for ( int i = 0; i < numberOfEvents; i++ ) {
            followSocialUserEventEvent.fire( new FollowSocialUserEvent( new SocialUser( "stress1" ), new SocialUser( "stress2" ) ) );
            events = events + 1;
            newRepositoryEvent.fire( new NewRepositoryEvent( getRepository(events) ) );
            events = events + 1;
            followSocialUserEventEvent.fire( new FollowSocialUserEvent( new SocialUser( "stress1" ), new SocialUser( "stress2" ) ) );
            events = events + 1;
            newRepositoryEvent.fire( new NewRepositoryEvent( getRepository(events) ) );
            events = events + 1;
            followSocialUserEventEvent.fire( new FollowSocialUserEvent( new SocialUser( "stress1" ), new SocialUser( "stress2" ) ) );
            events = events + 1;
            newRepositoryEvent.fire( new NewRepositoryEvent( getRepository(events) ) );
            events = events + 1;
            followSocialUserEventEvent.fire( new FollowSocialUserEvent( new SocialUser( "stress1" ), new SocialUser( "stress2" ) ) );
            events = events + 1;
            newRepositoryEvent.fire( new NewRepositoryEvent( getRepository(events) ) );
            events = events + 1;
            followSocialUserEventEvent.fire( new FollowSocialUserEvent( new SocialUser( "stress1" ), new SocialUser( "stress2" ) ) );
            events = events + 1;
            newRepositoryEvent.fire( new NewRepositoryEvent( getRepository(events) ) );
            if ( sleep > 0 ) {
                try {
                    Thread.sleep( sleep );
                } catch ( InterruptedException e ) {
                    e.printStackTrace();
                }
            }

        }

        return events;
    }

    public Repository getRepository( final int i) {
        return new Repository() {
            @Override
            public String getAlias() {
                return "stress test repo" + i;
            }

            @Override
            public String getScheme() {
                return null;
            }

            @Override
            public Map<String, Object> getEnvironment() {
                return null;
            }

            @Override
            public void addEnvironmentParameter( String key,
                                                 Object value ) {

            }

            @Override
            public boolean isValid() {
                return false;
            }

            @Override
            public String getUri() {
                return null;
            }

            @Override
            public List<PublicURI> getPublicURIs() {
                return null;
            }

            @Override
            public Path getRoot() {
                return null;
            }

            @Override
            public void setRoot( Path root ) {

            }

            public Collection<String> getBranches() {
                return null;
            }

            public String getCurrentBranch() {
                return null;
            }

            @Override
            public boolean requiresRefresh() {
                return false;
            }

            @Override
            public void markAsCached() {

            }

            @Override
            public String getSignatureId() {
                return null;
            }

            @Override
            public Collection<String> getRoles() {
                return null;
            }

            @Override
            public Collection<String> getTraits() {
                return null;
            }
        };
    }
}