Skip to content
Snippets Groups Projects
Commit c2ea8953 authored by Simon Spinner's avatar Simon Spinner
Browse files

Initial version

parents
No related branches found
No related tags found
No related merge requests found
Hide whitespace changes
Inline Side-by-side
Showing
with 1469 additions and 0 deletions
extension/.gitignore 0 → 100644
+ 1
− 0
View file @ c2ea8953
/target/
extension/pom.xml 0 → 100644
+ 355
− 0
View file @ c2ea8953
<?xml version="1.0" encoding="UTF-8"?>
<!-- ~ JBoss, Home of Professional Open Source. ~ Copyright 2010, Red Hat,
Inc., and individual contributors ~ as indicated by the @author tags. See
the copyright.txt file in the ~ distribution for a full listing of individual
contributors. ~ ~ This is free software; you can redistribute it and/or modify
it ~ under the terms of the GNU Lesser General Public License as ~ published
by the Free Software Foundation; either version 2.1 of ~ the License, or
(at your option) any later version. ~ ~ This software is distributed in the
hope that it will be useful, ~ but WITHOUT ANY WARRANTY; without even the
implied warranty of ~ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU ~ Lesser General Public License for more details. ~ ~ You should
have received a copy of the GNU Lesser General Public ~ License along with
this software; if not, write to the Free ~ Software Foundation, Inc., 51
Franklin St, Fifth Floor, Boston, MA ~ 02110-1301 USA, or see the FSF site:
http://www.fsf.org. -->
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<!-- parent> <groupId>org.jboss.as</groupId> <artifactId>jboss-as-parent</artifactId>
</parent -->
<groupId>perfmodel.wildfly</groupId>
<artifactId>extension</artifactId>
<version>1.0-SNAPSHOT</version>
<name>WildFly: Subsystem Artifact</name>
<packaging>jar</packaging>
<properties>
<version.wildfly>8.2.0.Final</version.wildfly>
<version.junit>4.11</version.junit>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<module.name>perfmodel.wildfly.extension</module.name>
</properties>
<scm>
<connection>scm:git:https://github.com/wildfly/archetypes.git</connection>
<developerConnection>scm:git:https://github.com/wildfly/archetypes.git</developerConnection>
<url>https://github.com/wildfly/archetypes/</url>
</scm>
<licenses>
<license>
<name>LGPL 2.1</name>
<url>http://www.gnu.org/licenses/lgpl-2.1.html</url>
<distribution>repo</distribution>
</license>
</licenses>
<repositories>
<repository>
<id>uw-nexus</id>
<name>Descartes Repository</name>
<url>https://se4.informatik.uni-wuerzburg.de/nexus/content/repositories/releases</url>
</repository>
</repositories>
<build>
<!-- Maven will append the version to the finalName (which is the name
given to the generated war, and hence the context root) -->
<finalName>${project.artifactId}</finalName>
<plugins>
<plugin>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.1</version>
<configuration>
<source>1.7</source>
<target>1.7</target>
</configuration>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-surefire-plugin</artifactId>
<version>2.16</version>
<configuration>
<redirectTestOutputToFile>true</redirectTestOutputToFile>
<enableAssertions>true</enableAssertions>
<argLine>-Xmx512m</argLine>
<systemProperties>
<property>
<name>jboss.home</name>
<value>${jboss.home}</value>
</property>
</systemProperties>
<includes>
<include>**/*TestCase.java</include>
</includes>
<forkMode>once</forkMode>
</configuration>
</plugin>
<plugin>
<artifactId>maven-assembly-plugin</artifactId>
<version>2.4</version>
<configuration>
<filters>
<filter>src/assemble/filter.properties</filter>
</filters>
<descriptors>
<descriptor>src/assemble/distribution.xml</descriptor>
</descriptors>
</configuration>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-dependency-plugin</artifactId>
<version>2.10</version>
<executions>
<execution>
<id>copy</id>
<phase>package</phase>
<goals>
<goal>copy</goal>
</goals>
<configuration>
<artifactItems>
<artifactItem>
<groupId>edu.kit.ipd.descartes.dml.mm</groupId>
<artifactId>edu.kit.ipd.descartes.identifier</artifactId>
<version>1.0.0</version>
<type>jar</type>
</artifactItem>
<artifactItem>
<groupId>edu.kit.ipd.descartes.dml.mm</groupId>
<artifactId>edu.kit.ipd.descartes.core</artifactId>
<version>1.0.0</version>
<type>jar</type>
</artifactItem>
<artifactItem>
<groupId>edu.kit.ipd.descartes.dml.mm</groupId>
<artifactId>edu.kit.ipd.descartes.mm.applicationlevel</artifactId>
<version>1.0.0</version>
<type>jar</type>
</artifactItem>
<artifactItem>
<groupId>edu.kit.ipd.descartes.dml.mm</groupId>
<artifactId>edu.kit.ipd.descartes.mm.applicationlevel.library</artifactId>
<version>1.0.0</version>
<type>jar</type>
</artifactItem>
<artifactItem>
<groupId>edu.kit.ipd.descartes.dml.mm</groupId>
<artifactId>edu.kit.ipd.descartes.mm.resourcelandscape</artifactId>
<version>1.0.0</version>
</artifactItem>
<artifactItem>
<groupId>edu.kit.ipd.descartes.dml.mm</groupId>
<artifactId>edu.kit.ipd.descartes.mm.deployment</artifactId>
<version>1.0.0</version>
</artifactItem>
<artifactItem>
<groupId>org.eclipse.emf</groupId>
<artifactId>org.eclipse.emf.common</artifactId>
<version>2.10.1</version>
<type>jar</type>
</artifactItem>
<artifactItem>
<groupId>org.eclipse.emf</groupId>
<artifactId>org.eclipse.emf.ecore</artifactId>
<version>2.10.1</version>
<type>jar</type>
</artifactItem>
<artifactItem>
<groupId>org.eclipse.emf</groupId>
<artifactId>org.eclipse.emf.ecore.xmi</artifactId>
<version>2.10.1</version>
<type>jar</type>
</artifactItem>
<artifactItem>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.34</version>
</artifactItem>
</artifactItems>
<outputDirectory>${project.build.dir}</outputDirectory>
</configuration>
</execution>
</executions>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-antrun-plugin</artifactId>
<inherited>false</inherited>
<version>1.7</version>
<executions>
<execution>
<id>build-dist</id>
<goals>
<goal>run</goal>
</goals>
<phase>package</phase>
<configuration>
<target>
<!-- Replace the '.' in ${module.name} with '/' to get its path -->
<tempfile property="temp.file" />
<echo message="${module.name}" file="${temp.file}" />
<replace file="${temp.file}" token="." value="/" />
<loadfile srcfile="${temp.file}" property="module.path" />
<delete file="${temp.file}" />
<delete dir="target/module" />
<property name="module.dir" value="target/module/${module.path}/main" />
<copy file="src/main/resources/module/main/module.xml"
tofile="${module.dir}/module.xml" />
<copy file="target/${project.artifactId}.jar" todir="${module.dir}" />
<copy todir="${module.dir}">
<fileset dir="target/dependency">
<include name="*.jar" />
</fileset>
</copy>
<echo>Module ${module.name} has been created in the
target/module directory. Copy to your WildFly installation.</echo>
</target>
</configuration>
</execution>
</executions>
</plugin>
</plugins>
</build>
<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.wildfly</groupId>
<artifactId>wildfly-controller</artifactId>
<version>${version.wildfly}</version>
</dependency>
<dependency>
<groupId>org.wildfly</groupId>
<artifactId>wildfly-server</artifactId>
<version>${version.wildfly}</version>
</dependency>
<dependency>
<groupId>org.wildfly</groupId>
<artifactId>wildfly-ejb3</artifactId>
<version>${version.wildfly}</version>
</dependency>
<dependency>
<groupId>org.wildfly</groupId>
<artifactId>wildfly-messaging</artifactId>
<version>${version.wildfly}</version>
</dependency>
<dependency>
<groupId>org.wildfly</groupId>
<artifactId>wildfly-undertow</artifactId>
<version>${version.wildfly}</version>
</dependency>
<dependency>
<groupId>org.wildfly</groupId>
<artifactId>wildfly-subsystem-test</artifactId>
<type>pom</type>
<scope>test</scope>
<version>${version.wildfly}</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<scope>test</scope>
<version>${version.junit}</version>
</dependency>
</dependencies>
</dependencyManagement>
<dependencies>
<dependency>
<groupId>org.wildfly</groupId>
<artifactId>wildfly-controller</artifactId>
</dependency>
<dependency>
<groupId>org.wildfly</groupId>
<artifactId>wildfly-server</artifactId>
</dependency>
<dependency>
<groupId>org.wildfly</groupId>
<artifactId>wildfly-ejb3</artifactId>
</dependency>
<dependency>
<groupId>org.wildfly</groupId>
<artifactId>wildfly-messaging</artifactId>
</dependency>
<dependency>
<groupId>org.wildfly</groupId>
<artifactId>wildfly-undertow</artifactId>
</dependency>
<dependency>
<groupId>commons-lang</groupId>
<artifactId>commons-lang</artifactId>
<version>2.6</version>
</dependency>
<dependency>
<groupId>edu.kit.ipd.descartes.dml.mm</groupId>
<artifactId>edu.kit.ipd.descartes.mm.applicationlevel</artifactId>
<version>1.0.0</version>
</dependency>
<dependency>
<groupId>edu.kit.ipd.descartes.dml.mm</groupId>
<artifactId>edu.kit.ipd.descartes.core</artifactId>
<version>1.0.0</version>
</dependency>
<dependency>
<groupId>edu.kit.ipd.descartes.dml.mm</groupId>
<artifactId>edu.kit.ipd.descartes.mm.applicationlevel.library</artifactId>
<version>1.0.0</version>
</dependency>
<dependency>
<groupId>edu.kit.ipd.descartes.dml.mm</groupId>
<artifactId>edu.kit.ipd.descartes.identifier</artifactId>
<version>1.0.0</version>
</dependency>
<dependency>
<groupId>edu.kit.ipd.descartes.dml.mm</groupId>
<artifactId>edu.kit.ipd.descartes.mm.resourcelandscape</artifactId>
<version>1.0.0</version>
</dependency>
<dependency>
<groupId>edu.kit.ipd.descartes.dml.mm</groupId>
<artifactId>edu.kit.ipd.descartes.mm.deployment</artifactId>
<version>1.0.0</version>
</dependency>
<dependency>
<groupId>org.eclipse.emf</groupId>
<artifactId>org.eclipse.emf.common</artifactId>
<version>2.10.1</version>
</dependency>
<dependency>
<groupId>org.eclipse.emf</groupId>
<artifactId>org.eclipse.emf.ecore</artifactId>
<version>2.10.1</version>
</dependency>
<dependency>
<groupId>org.eclipse.emf</groupId>
<artifactId>org.eclipse.emf.ecore.xmi</artifactId>
<version>2.10.1</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.34</version>
</dependency>
<dependency>
<groupId>org.wildfly</groupId>
<artifactId>wildfly-subsystem-test</artifactId>
<type>pom</type>
<scope>test</scope>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
</project>
extension/src/main/java/perfmodel/wildfly/Constants.java 0 → 100644
+ 5
− 0
View file @ c2ea8953
package perfmodel.wildfly;
public class Constants {
public static final long NANOS_IN_MILLIS = 1000000;
}
extension/src/main/java/perfmodel/wildfly/callstack/ComponentRecord.java 0 → 100644
+ 42
− 0
View file @ c2ea8953
package perfmodel.wildfly.callstack;
import java.util.Collection;
import java.util.concurrent.ConcurrentHashMap;
public class ComponentRecord {
private final String component;
private String componentClass = null;
private final ConcurrentHashMap<String, InterfaceRecord> interfaces = new ConcurrentHashMap<>();
public ComponentRecord(String component) {
this.component = component;
}
public void setComponentClass(String componentClass) {
this.componentClass = componentClass;
}
public String getComponentClass() {
return componentClass;
}
public String getComponentName() {
return component;
}
public InterfaceRecord requireInterface(String interf) {
InterfaceRecord record = interfaces.get(interf);
if (record == null) {
record = new InterfaceRecord(this, interf);
if (interfaces.putIfAbsent(interf, record) != null) {
// a different thread has changed it in the mean time
record = interfaces.get(interf);
}
}
return record;
}
public Collection<InterfaceRecord> getInterfaces() {
return interfaces.values();
}
}
extension/src/main/java/perfmodel/wildfly/callstack/InterfaceRecord.java 0 → 100644
+ 41
− 0
View file @ c2ea8953
package perfmodel.wildfly.callstack;
import java.util.Collection;
import java.util.concurrent.ConcurrentHashMap;
public class InterfaceRecord {
private final String interf;
private final ComponentRecord component;
private final ConcurrentHashMap<String, OperationRecord> operations = new ConcurrentHashMap<>();
public InterfaceRecord(ComponentRecord component, String interf) {
this.component = component;
this.interf = interf;
}
public String getInterfaceName() {
return interf;
}
public ComponentRecord getComponent() {
return component;
}
public OperationRecord requireOperation(String operation) {
OperationRecord record = operations.get(operation);
if (record == null) {
record = new OperationRecord(this, operation);
if (operations.putIfAbsent(operation, record) != null) {
// a different thread has changed it in the mean time
record = operations.get(operation);
}
}
return record;
}
public Collection<OperationRecord> getOperations() {
return operations.values();
}
}
extension/src/main/java/perfmodel/wildfly/callstack/OperationRecord.java 0 → 100644
+ 57
− 0
View file @ c2ea8953
package perfmodel.wildfly.callstack;
import java.util.Collection;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicLong;
public class OperationRecord {
private final InterfaceRecord interf;
private final String operation;
private final AtomicLong invocationCount = new AtomicLong();
private final AtomicLong executionTime = new AtomicLong();
private final ConcurrentHashMap<String, ComponentRecord> requiredComponents = new ConcurrentHashMap<String, ComponentRecord>();
public OperationRecord(InterfaceRecord interf, String operation) {
this.interf = interf;
this.operation = operation;
}
public InterfaceRecord getInterface() {
return interf;
}
public String getOperationName() {
return operation;
}
public long getInvocationCount() {
return invocationCount.get();
}
public long getExecutionTime() {
return executionTime.get();
}
public void addInvocation(long time) {
invocationCount.incrementAndGet();
executionTime.addAndGet(time);
}
public ComponentRecord requireComponent(String component) {
ComponentRecord record = requiredComponents.get(component);
if (record == null) {
record = new ComponentRecord(component);
if (requiredComponents.putIfAbsent(component, record) != null) {
// a different thread has changed it in the mean time
record = requiredComponents.get(component);
}
}
return record;
}
public Collection<ComponentRecord> getRequiredComponents() {
return requiredComponents.values();
}
}
extension/src/main/java/perfmodel/wildfly/callstack/ThreadCallStack.java 0 → 100644
+ 17
− 0
View file @ c2ea8953
package perfmodel.wildfly.callstack;
import java.util.ArrayDeque;
import java.util.Deque;
public class ThreadCallStack {
private static final ThreadLocal<Deque<OperationRecord>> callStack = new ThreadLocal<Deque<OperationRecord>>() {
protected Deque<OperationRecord> initialValue() {
return new ArrayDeque<OperationRecord>(10);
};
};
public static Deque<OperationRecord> get() {
return callStack.get();
}
}
extension/src/main/java/perfmodel/wildfly/deployment/AddDependenciesDeploymentProcessor.java 0 → 100644
+ 53
− 0
View file @ c2ea8953
package perfmodel.wildfly.deployment;
import org.jboss.as.server.deployment.Attachments;
import org.jboss.as.server.deployment.DeploymentPhaseContext;
import org.jboss.as.server.deployment.DeploymentUnit;
import org.jboss.as.server.deployment.DeploymentUnitProcessingException;
import org.jboss.as.server.deployment.DeploymentUnitProcessor;
import org.jboss.as.server.deployment.Phase;
import org.jboss.as.server.deployment.module.ModuleDependency;
import org.jboss.as.server.deployment.module.ModuleSpecification;
import org.jboss.logging.Logger;
import org.jboss.modules.Module;
import org.jboss.modules.ModuleIdentifier;
import org.jboss.modules.ModuleLoader;
/**
* This deployment processor adds our module as dependency to all deployment units, so that
* interceptor classes are found.
*
* @author <a href="simon.spinner@uni-wuerzburg.de">Simon Spinner</a>
*/
public class AddDependenciesDeploymentProcessor implements DeploymentUnitProcessor {
Logger log = Logger.getLogger(AddDependenciesDeploymentProcessor.class);
/**
* See {@link Phase} for a description of the different phases
*/
public static final Phase PHASE = Phase.DEPENDENCIES;
/**
* The relative order of this processor within the {@link #PHASE}.
* The current number is large enough for it to happen after all
* the standard deployment unit processors that come with JBoss AS.
*/
public static final int PRIORITY = 0x4000;
private static final ModuleIdentifier PERFMODEL = ModuleIdentifier.create("perfmodel.wildfly.extension");
@Override
public void deploy(DeploymentPhaseContext phaseContext) throws DeploymentUnitProcessingException {
DeploymentUnit deploymentUnit = phaseContext.getDeploymentUnit();
ModuleLoader moduleLoader = Module.getBootModuleLoader();
ModuleSpecification moduleSpecification = deploymentUnit.getAttachment(Attachments.MODULE_SPECIFICATION);
moduleSpecification.addSystemDependency(new ModuleDependency(moduleLoader, PERFMODEL, false, false, false, false));
log.info("Added module " + PERFMODEL.getName() + " as dependency to deployment unit " + deploymentUnit.getName());
}
@Override
public void undeploy(DeploymentUnit context) {
}
}
extension/src/main/java/perfmodel/wildfly/deployment/ClientInstrumentationDeploymentProcessor.java 0 → 100644
+ 64
− 0
View file @ c2ea8953
package perfmodel.wildfly.deployment;
import org.jboss.as.ee.component.Attachments;
import org.jboss.as.ee.component.ComponentConfiguration;
import org.jboss.as.ee.component.ComponentConfigurator;
import org.jboss.as.ee.component.ComponentDescription;
import org.jboss.as.ee.component.EEModuleDescription;
import org.jboss.as.ee.component.ViewConfiguration;
import org.jboss.as.ee.component.interceptors.InterceptorOrder;
import org.jboss.as.ejb3.component.EJBComponentDescription;
import org.jboss.as.ejb3.component.EJBViewConfiguration;
import org.jboss.as.ejb3.component.MethodIntf;
import org.jboss.as.ejb3.deployment.EjbDeploymentAttachmentKeys;
import org.jboss.as.server.AbstractDeploymentChainStep;
import org.jboss.as.server.deployment.DeploymentPhaseContext;
import org.jboss.as.server.deployment.DeploymentUnit;
import org.jboss.as.server.deployment.DeploymentUnitProcessingException;
import org.jboss.as.server.deployment.DeploymentUnitProcessor;
import org.jboss.as.server.deployment.Phase;
import org.jboss.ejb.client.EJBClientContext;
import org.jboss.invocation.ImmediateInterceptorFactory;
import org.jboss.logging.Logger;
import perfmodel.wildfly.interceptors.EJBIncomingCallInterceptor;
import perfmodel.wildfly.interceptors.EJBOutgoingCallInterceptor;
/**
* An example deployment unit processor that does nothing. To add more deployment
* processors copy this class, and add to the {@link AbstractDeploymentChainStep}
* {@link perfmodel.wildfly.extension.SubsystemAdd#performBoottime(org.jboss.as.controller.OperationContext, org.jboss.dmr.ModelNode, org.jboss.dmr.ModelNode, org.jboss.as.controller.ServiceVerificationHandler, java.util.List)}
*
* @author <a href="simon.spinner@uni-wuerzburg.de">Simon Spinner</a>
*/
public class ClientInstrumentationDeploymentProcessor implements DeploymentUnitProcessor {
Logger log = Logger.getLogger(ClientInstrumentationDeploymentProcessor.class);
/**
* See {@link Phase} for a description of the different phases
*/
public static final Phase PHASE = Phase.INSTALL;
/**
* The relative order of this processor within the {@link #PHASE}.
* The current number is large enough for it to happen after all
* the standard deployment unit processors that come with JBoss AS.
*/
public static final int PRIORITY = 0x4000;
@Override
public void deploy(DeploymentPhaseContext phaseContext) throws DeploymentUnitProcessingException {
DeploymentUnit deploymentUnit = phaseContext.getDeploymentUnit();
EJBClientContext ctx = deploymentUnit.getAttachment(EjbDeploymentAttachmentKeys.EJB_CLIENT_CONTEXT);
if (ctx != null) {
log.info("Register client-side interceptor for deployment unit " + deploymentUnit.getName());
ctx.registerInterceptor(Integer.MAX_VALUE, new EJBOutgoingCallInterceptor());
}
}
@Override
public void undeploy(DeploymentUnit context) {
}
}
extension/src/main/java/perfmodel/wildfly/deployment/ServerInstrumentationDeploymentProcessor.java 0 → 100644
+ 83
− 0
View file @ c2ea8953
package perfmodel.wildfly.deployment;
import org.jboss.as.ee.component.Attachments;
import org.jboss.as.ee.component.ComponentConfiguration;
import org.jboss.as.ee.component.ComponentConfigurator;
import org.jboss.as.ee.component.ComponentDescription;
import org.jboss.as.ee.component.EEModuleDescription;
import org.jboss.as.ee.component.ViewConfiguration;
import org.jboss.as.ee.component.interceptors.InterceptorOrder;
import org.jboss.as.ejb3.component.EJBComponentDescription;
import org.jboss.as.ejb3.component.EJBViewConfiguration;
import org.jboss.as.ejb3.component.MethodIntf;
import org.jboss.as.ejb3.deployment.EjbDeploymentAttachmentKeys;
import org.jboss.as.server.AbstractDeploymentChainStep;
import org.jboss.as.server.deployment.DeploymentPhaseContext;
import org.jboss.as.server.deployment.DeploymentUnit;
import org.jboss.as.server.deployment.DeploymentUnitProcessingException;
import org.jboss.as.server.deployment.DeploymentUnitProcessor;
import org.jboss.as.server.deployment.Phase;
import org.jboss.ejb.client.EJBClientContext;
import org.jboss.invocation.ImmediateInterceptorFactory;
import org.jboss.logging.Logger;
import perfmodel.wildfly.interceptors.EJBIncomingCallInterceptor;
import perfmodel.wildfly.interceptors.EJBOutgoingCallInterceptor;
import perfmodel.wildfly.service.MonitoringService;
/**
* An example deployment unit processor that does nothing. To add more deployment
* processors copy this class, and add to the {@link AbstractDeploymentChainStep}
* {@link perfmodel.wildfly.extension.SubsystemAdd#performBoottime(org.jboss.as.controller.OperationContext, org.jboss.dmr.ModelNode, org.jboss.dmr.ModelNode, org.jboss.as.controller.ServiceVerificationHandler, java.util.List)}
*
* @author <a href="simon.spinner@uni-wuerzburg.de">Simon Spinner</a>
*/
public class ServerInstrumentationDeploymentProcessor implements DeploymentUnitProcessor {
Logger log = Logger.getLogger(ServerInstrumentationDeploymentProcessor.class);
/**
* See {@link Phase} for a description of the different phases
*/
public static final Phase PHASE = Phase.POST_MODULE;
/**
* The relative order of this processor within the {@link #PHASE}.
* The current number is large enough for it to happen after all
* the standard deployment unit processors that come with JBoss AS.
*/
public static final int PRIORITY = 0x4000;
@Override
public void deploy(DeploymentPhaseContext phaseContext) throws DeploymentUnitProcessingException {
DeploymentUnit deploymentUnit = phaseContext.getDeploymentUnit();
log.info("Instrumenting deployment unit: " + deploymentUnit.getName());
EEModuleDescription eeModuleDescription = deploymentUnit.getAttachment(Attachments.EE_MODULE_DESCRIPTION);
for (ComponentDescription componentDescription : eeModuleDescription.getComponentDescriptions()) {
if (!(componentDescription instanceof EJBComponentDescription)) {
continue;
}
EJBComponentDescription ejb = (EJBComponentDescription)componentDescription;
log.info("Register server-side interceptor for EJB " + ejb.getEJBName());
ejb.getConfigurators().add(new ComponentConfigurator() {
@Override
public void configure(DeploymentPhaseContext context, ComponentDescription description,
ComponentConfiguration configuration) throws DeploymentUnitProcessingException {
MonitoringService service = (MonitoringService)context.getServiceRegistry().getRequiredService(MonitoringService.SERVICE_NAME).getValue();
EJBIncomingCallInterceptor interceptor = new EJBIncomingCallInterceptor(service);
ImmediateInterceptorFactory factory = new ImmediateInterceptorFactory(interceptor);
for (ViewConfiguration view : configuration.getViews()) {
view.addViewInterceptor(factory, InterceptorOrder.Component.EJB_EXECUTION_TIME_INTERCEPTOR - 1);
}
}
});
}
log.info("Successfully instrumented deployment unit: " + deploymentUnit.getName());
}
@Override
public void undeploy(DeploymentUnit context) {
}
}
extension/src/main/java/perfmodel/wildfly/extension/ModelExtractionHandler.java 0 → 100644
+ 130
− 0
View file @ c2ea8953
package perfmodel.wildfly.extension;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.util.Collections;
import java.util.Map;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.resource.ResourceSet;
import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl;
import org.eclipse.emf.ecore.xmi.impl.XMIResourceFactoryImpl;
import org.jboss.as.controller.OperationContext;
import org.jboss.as.controller.OperationFailedException;
import org.jboss.as.controller.OperationStepHandler;
import org.jboss.dmr.ModelNode;
import org.jboss.msc.service.ServiceRegistry;
import perfmodel.wildfly.service.ModelExtractionService;
import edu.kit.ipd.descartes.mm.applicationlevel.repository.Repository;
import edu.kit.ipd.descartes.mm.applicationlevel.repository.RepositoryPackage;
import edu.kit.ipd.descartes.mm.deployment.Deployment;
import edu.kit.ipd.descartes.mm.deployment.DeploymentPackage;
import edu.kit.ipd.descartes.mm.resourcelandscape.DistributedDataCenter;
import edu.kit.ipd.descartes.mm.resourcetype.ResourceTypeRepository;
public class ModelExtractionHandler implements OperationStepHandler {
static final ModelExtractionHandler INSTANCE = new ModelExtractionHandler();
@Override
public void execute(OperationContext context, ModelNode operation) throws OperationFailedException {
ServiceRegistry registry = context.getServiceRegistry(false);
ModelExtractionService service = (ModelExtractionService) registry.getService(ModelExtractionService.SERVICE_NAME).getValue();
RepositoryPackage.eINSTANCE.eClass();
DeploymentPackage.eINSTANCE.eClass();
String applicationName = operation.get("application").asString();
String resourceTypesString = operation.get("resourcetypes").asString();
String repositoryString = operation.get("repository").asString();
String systemString = null;
if (operation.get("system").isDefined()) {
systemString = operation.get("system").asString();
}
String deploymentString = null;
String resourceLandscapeString = null;
String host = null;
if (operation.get("deployment").isDefined()) {
resourceLandscapeString = operation.get("resourcelandscape").asString();
deploymentString = operation.get("deployment").asString();
host = operation.get("host").asString();
}
System.out.println(host);
ResourceSet resSet = createResourceSet();
ResourceTypeRepository resourceTypes = (ResourceTypeRepository)load(resSet, URI.createURI("pathmap://DML_APPLICATIONLEVEL_MODELS/defaultresourcetypes.resourcetype"), resourceTypesString);
Repository repository = (Repository)load(resSet, applicationName + ".repository", repositoryString);
edu.kit.ipd.descartes.mm.applicationlevel.system.System system = null;
if (systemString != null) {
system = (edu.kit.ipd.descartes.mm.applicationlevel.system.System)load(resSet, applicationName + ".system", systemString);
}
DistributedDataCenter resourceLandscape;
Deployment deployment = null;
if (deploymentString != null) {
resourceLandscape = (DistributedDataCenter)load(resSet, applicationName + ".resourcelandscape", resourceLandscapeString);
deployment = (Deployment)load(resSet, applicationName + ".deployment", deploymentString);
}
if (system == null) {
service.extractApplicationArchitecture(resourceTypes, repository);
} else {
if (deployment == null) {
service.extractSystemAssembly(repository, system);
} else {
service.extractDeployment(repository, system, deployment, host);
}
}
try {
ByteArrayOutputStream out = new ByteArrayOutputStream();
if (system == null) {
repository.eResource().save(out, Collections.EMPTY_MAP);
} else if (deployment == null) {
system.eResource().save(out, Collections.EMPTY_MAP);
} else {
deployment.eResource().save(out, Collections.emptyMap());
}
context.getResult().add(out.toString());
} catch (IOException e) {
e.printStackTrace();
}
System.out.println("Model extraction called");
context.stepCompleted();
}
private EObject load(ResourceSet resSet, String uri, String content) {
return load(resSet, URI.createPlatformResourceURI(uri, false), content);
}
private EObject load(ResourceSet resSet, URI uri, String content) {
Resource resource = resSet.createResource(uri);
try {
resource.load(new ByteArrayInputStream(content.getBytes()), Collections.EMPTY_MAP);
return resource.getContents().get(0);
} catch (IOException e1) {
e1.printStackTrace();
return null;
}
}
private ResourceSet createResourceSet() {
Resource.Factory.Registry reg = Resource.Factory.Registry.INSTANCE;
Map<String, Object> m = reg.getExtensionToFactoryMap();
m.put("repository", new XMIResourceFactoryImpl());
m.put("system", new XMIResourceFactoryImpl());
m.put("resourcelandscape", new XMIResourceFactoryImpl());
m.put("resourcetype", new XMIResourceFactoryImpl());
m.put("deployment", new XMIResourceFactoryImpl());
ResourceSet resSet = new ResourceSetImpl();
return resSet;
}
}
extension/src/main/java/perfmodel/wildfly/extension/SubsystemAdd.java 0 → 100644
+ 88
− 0
View file @ c2ea8953
package perfmodel.wildfly.extension;
import java.util.List;
import org.hornetq.core.server.HornetQServer;
import org.jboss.as.controller.AbstractBoottimeAddStepHandler;
import org.jboss.as.controller.OperationContext;
import org.jboss.as.controller.OperationFailedException;
import org.jboss.as.controller.ServiceVerificationHandler;
import org.jboss.as.messaging.MessagingServices;
import org.jboss.as.server.AbstractDeploymentChainStep;
import org.jboss.as.server.DeploymentProcessorTarget;
import org.jboss.dmr.ModelNode;
import org.jboss.msc.service.ServiceController;
import org.jboss.msc.service.ServiceController.Mode;
import org.jboss.msc.service.ServiceName;
import org.wildfly.extension.undertow.Host;
import org.wildfly.extension.undertow.UndertowService;
import perfmodel.wildfly.deployment.AddDependenciesDeploymentProcessor;
import perfmodel.wildfly.deployment.ClientInstrumentationDeploymentProcessor;
import perfmodel.wildfly.deployment.ServerInstrumentationDeploymentProcessor;
import perfmodel.wildfly.service.InstrumentationService;
import perfmodel.wildfly.service.ModelExtractionService;
import perfmodel.wildfly.service.MonitoringService;
/**
* Handler responsible for adding the subsystem resource to the model
*
* @author <a href="kabir.khan@jboss.com">Kabir Khan</a>
*/
class SubsystemAdd extends AbstractBoottimeAddStepHandler {
static final SubsystemAdd INSTANCE = new SubsystemAdd();
private SubsystemAdd() {
}
/**
* {@inheritDoc}
*/
@Override
protected void populateModel(ModelNode operation, ModelNode model) throws OperationFailedException {
}
/**
* {@inheritDoc}
*/
@Override
public void performBoottime(OperationContext context, ModelNode operation, ModelNode model,
ServiceVerificationHandler verificationHandler, List<ServiceController<?>> newControllers)
throws OperationFailedException {
//Add deployment processors here
//Remove this if you don't need to hook into the deployers, or you can add as many as you like
//see SubDeploymentProcessor for explanation of the phases
context.addStep(new AbstractDeploymentChainStep() {
public void execute(DeploymentProcessorTarget processorTarget) {
processorTarget.addDeploymentProcessor(SubsystemExtension.SUBSYSTEM_NAME, AddDependenciesDeploymentProcessor.PHASE, AddDependenciesDeploymentProcessor.PRIORITY, new AddDependenciesDeploymentProcessor());
processorTarget.addDeploymentProcessor(SubsystemExtension.SUBSYSTEM_NAME, ServerInstrumentationDeploymentProcessor.PHASE, ServerInstrumentationDeploymentProcessor.PRIORITY, new ServerInstrumentationDeploymentProcessor());
processorTarget.addDeploymentProcessor(SubsystemExtension.SUBSYSTEM_NAME, ClientInstrumentationDeploymentProcessor.PHASE, ClientInstrumentationDeploymentProcessor.PRIORITY, new ClientInstrumentationDeploymentProcessor());
}
}, OperationContext.Stage.RUNTIME);
ServiceController<MonitoringService> monitoringController = context.getServiceTarget().addService(MonitoringService.SERVICE_NAME, MonitoringService.INSTANCE).setInitialMode(Mode.ACTIVE).install();
ModelExtractionService extractionService = new ModelExtractionService();
ServiceController<ModelExtractionService> extractionController = context.getServiceTarget()
.addService(ModelExtractionService.SERVICE_NAME, extractionService)
.setInitialMode(Mode.ACTIVE)
.addDependency(MonitoringService.SERVICE_NAME, MonitoringService.class, extractionService.getMonitoringService())
.install();
ServiceName undertowHost = UndertowService.DEFAULT_HOST;
InstrumentationService instrumentationService = new InstrumentationService();
ServiceController<InstrumentationService> instrumentationController = context.getServiceTarget()
.addService(InstrumentationService.SERVICE_NAME, instrumentationService)
.setInitialMode(Mode.ACTIVE)
.addDependency(undertowHost, Host.class, instrumentationService.getUndertowHost())
.install();
newControllers.add(monitoringController);
newControllers.add(extractionController);
//newControllers.add(instrumentationController);
}
}
extension/src/main/java/perfmodel/wildfly/extension/SubsystemDefinition.java 0 → 100644
+ 47
− 0
View file @ c2ea8953
package perfmodel.wildfly.extension;
import org.jboss.as.controller.OperationDefinition;
import org.jboss.as.controller.SimpleAttributeDefinition;
import org.jboss.as.controller.SimpleOperationDefinitionBuilder;
import org.jboss.as.controller.SimpleResourceDefinition;
import org.jboss.as.controller.registry.ManagementResourceRegistration;
import org.jboss.dmr.ModelType;
/**
* @author <a href="mailto:tcerar@redhat.com">Tomaz Cerar</a>
*/
public class SubsystemDefinition extends SimpleResourceDefinition {
public static final SubsystemDefinition INSTANCE = new SubsystemDefinition();
static final OperationDefinition EXTRACT_PERFORMANCE_MODEL = new SimpleOperationDefinitionBuilder("extract-performance-model", SubsystemExtension.getResourceDescriptionResolver(null))
.addParameter(new SimpleAttributeDefinition("application", ModelType.STRING, false))
.addParameter(new SimpleAttributeDefinition("resourcetypes", ModelType.STRING, false))
.addParameter(new SimpleAttributeDefinition("repository", ModelType.STRING, false))
.addParameter(new SimpleAttributeDefinition("system", ModelType.STRING, false))
.addParameter(new SimpleAttributeDefinition("deployment", ModelType.STRING, false))
.addParameter(new SimpleAttributeDefinition("resourcelandscape", ModelType.STRING, false))
.addParameter(new SimpleAttributeDefinition("host", ModelType.STRING, false))
.setReplyType(ModelType.STRING)
.build();
private SubsystemDefinition() {
super(SubsystemExtension.SUBSYSTEM_PATH,
SubsystemExtension.getResourceDescriptionResolver(null),
//We always need to add an 'add' operation
SubsystemAdd.INSTANCE,
//Every resource that is added, normally needs a remove operation
SubsystemRemove.INSTANCE);
}
@Override
public void registerOperations(ManagementResourceRegistration resourceRegistration) {
super.registerOperations(resourceRegistration);
//you can register aditional operations here
resourceRegistration.registerOperationHandler(EXTRACT_PERFORMANCE_MODEL, ModelExtractionHandler.INSTANCE);
}
@Override
public void registerAttributes(ManagementResourceRegistration resourceRegistration) {
//you can register attributes here
}
}
extension/src/main/java/perfmodel/wildfly/extension/SubsystemExtension.java 0 → 100644
+ 106
− 0
View file @ c2ea8953
package perfmodel.wildfly.extension;
import org.jboss.as.controller.Extension;
import org.jboss.as.controller.ExtensionContext;
import org.jboss.as.controller.PathElement;
import org.jboss.as.controller.SubsystemRegistration;
import org.jboss.as.controller.descriptions.StandardResourceDescriptionResolver;
import org.jboss.as.controller.operations.common.GenericSubsystemDescribeHandler;
import org.jboss.as.controller.parsing.ExtensionParsingContext;
import org.jboss.as.controller.parsing.ParseUtils;
import org.jboss.as.controller.persistence.SubsystemMarshallingContext;
import org.jboss.as.controller.registry.ManagementResourceRegistration;
import org.jboss.as.controller.registry.OperationEntry;
import org.jboss.dmr.ModelNode;
import org.jboss.staxmapper.XMLElementReader;
import org.jboss.staxmapper.XMLElementWriter;
import org.jboss.staxmapper.XMLExtendedStreamReader;
import org.jboss.staxmapper.XMLExtendedStreamWriter;
import javax.xml.stream.XMLStreamConstants;
import javax.xml.stream.XMLStreamException;
import java.util.List;
import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.ADD;
import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.DESCRIBE;
import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.OP;
import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.OP_ADDR;
import static org.jboss.as.controller.descriptions.ModelDescriptionConstants.SUBSYSTEM;
/**
* @author <a href="kabir.khan@jboss.com">Kabir Khan</a>
*/
public class SubsystemExtension implements Extension {
/**
* The name space used for the {@code substystem} element
*/
public static final String NAMESPACE = "urn:mycompany:mysubsystem:1.0";
/**
* The name of our subsystem within the model.
*/
public static final String SUBSYSTEM_NAME = "mysubsystem";
/**
* The parser used for parsing our subsystem
*/
private final SubsystemParser parser = new SubsystemParser();
protected static final PathElement SUBSYSTEM_PATH = PathElement.pathElement(SUBSYSTEM, SUBSYSTEM_NAME);
private static final String RESOURCE_NAME = SubsystemExtension.class.getPackage().getName() + ".LocalDescriptions";
static StandardResourceDescriptionResolver getResourceDescriptionResolver(final String keyPrefix) {
String prefix = SUBSYSTEM_NAME + (keyPrefix == null ? "" : "." + keyPrefix);
return new StandardResourceDescriptionResolver(prefix, RESOURCE_NAME, SubsystemExtension.class.getClassLoader(), true, false);
}
@Override
public void initializeParsers(ExtensionParsingContext context) {
context.setSubsystemXmlMapping(SUBSYSTEM_NAME, NAMESPACE, parser);
}
@Override
public void initialize(ExtensionContext context) {
final SubsystemRegistration subsystem = context.registerSubsystem(SUBSYSTEM_NAME, 1, 0);
final ManagementResourceRegistration registration = subsystem.registerSubsystemModel(SubsystemDefinition.INSTANCE);
registration.registerOperationHandler(GenericSubsystemDescribeHandler.DEFINITION, GenericSubsystemDescribeHandler.INSTANCE);
subsystem.registerXMLElementWriter(parser);
}
private static ModelNode createAddSubsystemOperation() {
final ModelNode subsystem = new ModelNode();
subsystem.get(OP).set(ADD);
subsystem.get(OP_ADDR).add(SUBSYSTEM, SUBSYSTEM_NAME);
return subsystem;
}
/**
* The subsystem parser, which uses stax to read and write to and from xml
*/
private static class SubsystemParser implements XMLStreamConstants, XMLElementReader<List<ModelNode>>, XMLElementWriter<SubsystemMarshallingContext> {
/**
* {@inheritDoc}
*/
@Override
public void writeContent(XMLExtendedStreamWriter writer, SubsystemMarshallingContext context) throws XMLStreamException {
context.startSubsystemElement(SubsystemExtension.NAMESPACE, false);
writer.writeEndElement();
}
/**
* {@inheritDoc}
*/
@Override
public void readElement(XMLExtendedStreamReader reader, List<ModelNode> list) throws XMLStreamException {
// Require no content
ParseUtils.requireNoContent(reader);
list.add(createAddSubsystemOperation());
}
}
}
extension/src/main/java/perfmodel/wildfly/extension/SubsystemRemove.java 0 → 100644
+ 28
− 0
View file @ c2ea8953
package perfmodel.wildfly.extension;
import org.jboss.as.controller.AbstractRemoveStepHandler;
import org.jboss.as.controller.OperationContext;
import org.jboss.as.controller.OperationFailedException;
import org.jboss.dmr.ModelNode;
/**
* Handler responsible for removing the subsystem resource from the model
*
* @author <a href="kabir.khan@jboss.com">Kabir Khan</a>
*/
class SubsystemRemove extends AbstractRemoveStepHandler {
static final SubsystemRemove INSTANCE = new SubsystemRemove();
private SubsystemRemove() {
}
@Override
protected void performRuntime(OperationContext context, ModelNode operation, ModelNode model) throws OperationFailedException {
//Remove any services installed by the corresponding add handler here
//context.removeService(ServiceName.of("some", "name"));
}
}
extension/src/main/java/perfmodel/wildfly/interceptors/EJBIncomingCallInterceptor.java 0 → 100644
+ 70
− 0
View file @ c2ea8953
package perfmodel.wildfly.interceptors;
import java.util.Deque;
import org.jboss.as.ejb3.component.EJBComponent;
import org.jboss.as.ejb3.component.interceptors.AbstractEJBInterceptor;
import org.jboss.invocation.InterceptorContext;
import org.jboss.logging.Logger;
import org.jboss.msc.service.ServiceRegistry;
import perfmodel.wildfly.Constants;
import perfmodel.wildfly.callstack.ComponentRecord;
import perfmodel.wildfly.callstack.InterfaceRecord;
import perfmodel.wildfly.callstack.OperationRecord;
import perfmodel.wildfly.callstack.ThreadCallStack;
import perfmodel.wildfly.service.MonitoringService;
public class EJBIncomingCallInterceptor extends AbstractEJBInterceptor {
private static final Logger log = Logger.getLogger(EJBIncomingCallInterceptor.class);
private final MonitoringService monitoringService;
public EJBIncomingCallInterceptor(MonitoringService monitoringService) {
this.monitoringService = monitoringService;
}
@Override
public Object processInvocation(InterceptorContext ctx) throws Exception {
Deque<OperationRecord> threadCallStack = ThreadCallStack.get();
EJBComponent ejbComponent = getComponent(ctx, EJBComponent.class);
String component = ejbComponent.getApplicationName() + "/" + ejbComponent.getModuleName() + "/" + ejbComponent.getComponentName();
String componentClass = ejbComponent.getComponentClass().getName();
String interf = ctx.getMethod().getDeclaringClass().getName();
String operation = ctx.getMethod().getName();
OperationRecord caller = threadCallStack.peek();
ComponentRecord crec = monitoringService.requireComponent(component);
if (crec.getComponentClass() == null) {
crec.setComponentClass(componentClass);
}
InterfaceRecord irec = crec.requireInterface(interf);
OperationRecord orec = irec.requireOperation(operation);
threadCallStack.push(orec);
long startTime = System.nanoTime();
Object ret = ctx.proceed();
long endTime = System.nanoTime();
long executionTime = (endTime - startTime) / Constants.NANOS_IN_MILLIS;
if (caller != null) {
// this is a local call in the same thread
// also add a outgoing call to the callee component
if (log.isTraceEnabled()) {
log.info("Outgoing invocation (" + caller.getInterface().getInterfaceName() + ", " + caller.getOperationName() + ") -> (" + interf + ", " + operation + ", " + executionTime + "ms)");
}
OperationRecord callerOrec = caller.requireComponent(component).requireInterface(interf).requireOperation(operation);
callerOrec.addInvocation(executionTime);
}
if (log.isTraceEnabled()) {
log.info("Incoming invocation (" + component + ", " + operation + ", " + executionTime + "ms)");
}
orec.addInvocation(executionTime);
threadCallStack.pop();
return ret;
}
}
extension/src/main/java/perfmodel/wildfly/interceptors/EJBOutgoingCallInterceptor.java 0 → 100644
+ 64
− 0
View file @ c2ea8953
package perfmodel.wildfly.interceptors;
import java.util.Deque;
import org.apache.commons.lang.mutable.MutableLong;
import org.jboss.ejb.client.EJBClientInterceptor;
import org.jboss.ejb.client.EJBClientInvocationContext;
import org.jboss.logging.Logger;
import perfmodel.wildfly.Constants;
import perfmodel.wildfly.callstack.ComponentRecord;
import perfmodel.wildfly.callstack.InterfaceRecord;
import perfmodel.wildfly.callstack.OperationRecord;
import perfmodel.wildfly.callstack.ThreadCallStack;
public class EJBOutgoingCallInterceptor implements EJBClientInterceptor {
private static final Logger log = Logger.getLogger(EJBOutgoingCallInterceptor.class);
private static final ThreadLocal<MutableLong> invocationTime = new ThreadLocal<MutableLong>() {
protected MutableLong initialValue() {
return new MutableLong();
}
};
@Override
public void handleInvocation(EJBClientInvocationContext ctx) throws Exception {
Deque<OperationRecord> threadCallStack = ThreadCallStack.get();
OperationRecord currentOperation = threadCallStack.peek();
if (currentOperation != null) {
String component = ctx.getLocator().getAppName() + "/" + ctx.getLocator().getModuleName() + "/" + ctx.getLocator().getBeanName();
String interf = ctx.getInvokedMethod().getDeclaringClass().getName();
String operation = ctx.getInvokedMethod().getName();
ComponentRecord crec = currentOperation.requireComponent(component);
InterfaceRecord irec = crec.requireInterface(interf);
OperationRecord orec = irec.requireOperation(operation);
threadCallStack.push(orec);
invocationTime.get().setValue(System.nanoTime());
}
ctx.sendRequest();
}
@Override
public Object handleInvocationResult(EJBClientInvocationContext ctx) throws Exception {
long endTime = System.nanoTime();
Deque<OperationRecord> threadCallStack = ThreadCallStack.get();
if (!threadCallStack.isEmpty()) {
long executionTime = (endTime - invocationTime.get().longValue()) / Constants.NANOS_IN_MILLIS;
OperationRecord orec = threadCallStack.pop();
orec.addInvocation(executionTime);
if (log.isTraceEnabled()) {
OperationRecord caller = threadCallStack.peek();
log.trace("Outgoing invocation (" + caller.getInterface().getInterfaceName() + ", " + caller.getOperationName()
+ ") -> (" + orec.getInterface().getInterfaceName() + ", " + orec.getOperationName() + ", " + executionTime + "ms)");
}
}
return ctx.getResult();
}
}
extension/src/main/java/perfmodel/wildfly/interceptors/IncomingServletCallHandler.java 0 → 100644
+ 83
− 0
View file @ c2ea8953
package perfmodel.wildfly.interceptors;
import java.util.Deque;
import org.apache.commons.lang.mutable.MutableLong;
import org.jboss.as.ejb3.component.EJBComponent;
import org.jboss.logging.Logger;
import perfmodel.wildfly.Constants;
import perfmodel.wildfly.callstack.ComponentRecord;
import perfmodel.wildfly.callstack.InterfaceRecord;
import perfmodel.wildfly.callstack.OperationRecord;
import perfmodel.wildfly.callstack.ThreadCallStack;
import perfmodel.wildfly.service.MonitoringService;
import io.undertow.server.ExchangeCompletionListener;
import io.undertow.server.HttpHandler;
import io.undertow.server.HttpServerExchange;
import io.undertow.servlet.handlers.ServletRequestContext;
public class IncomingServletCallHandler implements HttpHandler, ExchangeCompletionListener {
private static final Logger log = Logger.getLogger(IncomingServletCallHandler.class);
private HttpHandler next;
private static final ThreadLocal<MutableLong> invocationTime = new ThreadLocal<MutableLong>() {
protected MutableLong initialValue() {
return new MutableLong();
}
};
public IncomingServletCallHandler(HttpHandler next) {
this.next = next;
}
@Override
public void handleRequest(HttpServerExchange req) throws Exception {
if (req.isInIoThread()) {
req.dispatch(this);
return;
}
req.addExchangeCompleteListener(this);
Deque<OperationRecord> threadCallStack = ThreadCallStack.get();
String component = req.getRequestPath();
String interf = "http:" + component;
Deque<String> actionParamter = req.getQueryParameters().get("action");
String operation = "invoke";
if (actionParamter != null) {
operation = actionParamter.getFirst();
}
ComponentRecord crec = MonitoringService.INSTANCE.requireComponent(component);
if (crec.getComponentClass() == null) {
crec.setComponentClass(component);
}
InterfaceRecord irec = crec.requireInterface(interf);
OperationRecord orec = irec.requireOperation(operation);
threadCallStack.push(orec);
invocationTime.get().setValue(System.nanoTime());
next.handleRequest(req);
}
@Override
public void exchangeEvent(HttpServerExchange arg0, NextListener nextListener) {
long endTime = System.nanoTime();
long startTime = invocationTime.get().longValue();
Deque<OperationRecord> threadCallStack = ThreadCallStack.get();
OperationRecord orec = threadCallStack.pop();
long executionTime = (endTime - startTime) / Constants.NANOS_IN_MILLIS;
if (log.isTraceEnabled()) {
log.info("Incoming invocation (" + orec.getInterface().getComponent().getComponentName() + ", " + orec.getOperationName()
+ ", " + executionTime + "ms)");
}
orec.addInvocation(executionTime);
nextListener.proceed();
}
}
extension/src/main/java/perfmodel/wildfly/interceptors/JDBCStatementInterceptor.java 0 → 100644
+ 87
− 0
View file @ c2ea8953
package perfmodel.wildfly.interceptors;
import java.sql.SQLException;
import java.util.Deque;
import java.util.Properties;
import org.apache.commons.lang.mutable.MutableLong;
import org.jboss.ejb.client.EJBClientInvocationContext;
import org.jboss.logging.Logger;
import perfmodel.wildfly.Constants;
import perfmodel.wildfly.callstack.ComponentRecord;
import perfmodel.wildfly.callstack.InterfaceRecord;
import perfmodel.wildfly.callstack.OperationRecord;
import perfmodel.wildfly.callstack.ThreadCallStack;
import com.mysql.jdbc.Connection;
import com.mysql.jdbc.ResultSetInternalMethods;
import com.mysql.jdbc.Statement;
import com.mysql.jdbc.StatementInterceptorV2;
public class JDBCStatementInterceptor implements StatementInterceptorV2 {
private static final Logger log = Logger.getLogger(EJBOutgoingCallInterceptor.class);
private static final ThreadLocal<MutableLong> invocationTime = new ThreadLocal<MutableLong>() {
protected MutableLong initialValue() {
return new MutableLong();
}
};
@Override
public void destroy() {
}
@Override
public boolean executeTopLevelOnly() {
return true;
}
@Override
public void init(Connection arg0, Properties arg1) throws SQLException {
}
@Override
public ResultSetInternalMethods preProcess(String sql, Statement interceptedStatemenet, Connection con) throws SQLException {
Deque<OperationRecord> threadCallStack = ThreadCallStack.get();
OperationRecord currentOperation = threadCallStack.peek();
if (currentOperation != null) {
String component = "mysql";
String interf = "sql";
String operation = "query";
ComponentRecord crec = currentOperation.requireComponent(component);
InterfaceRecord irec = crec.requireInterface(interf);
OperationRecord orec = irec.requireOperation(operation);
threadCallStack.push(orec);
invocationTime.get().setValue(System.nanoTime());
}
return null;
}
@Override
public ResultSetInternalMethods postProcess(String sql, Statement interceptedStatement, ResultSetInternalMethods res,
Connection con, int warnings, boolean noIndexUsed, boolean noGoodIndexUsed, SQLException ex) throws SQLException {
long endTime = System.nanoTime();
Deque<OperationRecord> threadCallStack = ThreadCallStack.get();
if (!threadCallStack.isEmpty()) {
long executionTime = (endTime - invocationTime.get().longValue()) / Constants.NANOS_IN_MILLIS;
OperationRecord orec = threadCallStack.pop();
orec.addInvocation(executionTime);
if (log.isTraceEnabled()) {
OperationRecord caller = threadCallStack.peek();
log.trace("Outgoing invocation (" + caller.getInterface().getInterfaceName() + ", " + caller.getOperationName()
+ ") -> (" + orec.getInterface().getInterfaceName() + ", " + orec.getOperationName() + ", " + executionTime + "ms)");
}
}
return null;
}
}
extension/src/main/java/perfmodel/wildfly/service/InstrumentationService.java 0 → 100644
+ 48
− 0
View file @ c2ea8953
package perfmodel.wildfly.service;
import org.hornetq.core.server.HornetQServer;
import org.jboss.logging.Logger;
import org.jboss.msc.service.Service;
import org.jboss.msc.service.ServiceName;
import org.jboss.msc.service.StartContext;
import org.jboss.msc.service.StartException;
import org.jboss.msc.service.StopContext;
import org.jboss.msc.value.InjectedValue;
import org.wildfly.extension.undertow.Host;
public class InstrumentationService implements Service<InstrumentationService> {
private static final Logger log = Logger.getLogger(InstrumentationService.class);
public static final ServiceName SERVICE_NAME = ServiceName.JBOSS.append("modelextraction", "instrumentation");
private final InjectedValue<Host> hostService = new InjectedValue<>();
private final InjectedValue<MonitoringService> monitoringService = new InjectedValue<>();
@Override
public InstrumentationService getValue() throws IllegalStateException, IllegalArgumentException {
return this;
}
@Override
public void start(StartContext ctx) throws StartException {
//hostService.getValue().registerHandler(path, handler);
}
@Override
public void stop(StopContext ctx) {
// TODO Auto-generated method stub
}
public InjectedValue<Host> getUndertowHost() {
return hostService;
}
public InjectedValue<MonitoringService> getMonitoringService() {
return monitoringService;
}
}
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment