Merge remote-tracking branch 'origin/master' (65679624) · Commits · SUMMER2020 / students / proj-2005033

skywalking-api/pom.xml

+44 −58

Original line number	Diff line number	Diff line
		@@ -12,6 +12,11 @@

		<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<version.plugin.shade>2.4.1</version.plugin.shade>
		<shade.net.bytebuddy.source>net.bytebuddy</shade.net.bytebuddy.source>
		<shade.net.bytebuddy.target>com.ai.cloud.skywalking.api.dependencies.net.bytebuddy</shade.net.bytebuddy.target>
		<shade.io.netty.source>io.netty</shade.io.netty.source>
		<shade.io.netty.target>com.ai.cloud.skywalking.api.dependencies.io.netty</shade.io.netty.target>
		</properties>

		<dependencies>
		@@ -22,73 +27,24 @@
		</dependency>

		<dependency>
		<groupId>org.apache.logging.log4j</groupId>
		<artifactId>log4j-core</artifactId>
		<version>2.4.1</version>
		<scope>provided</scope>
		<groupId>net.bytebuddy</groupId>
		<artifactId>byte-buddy</artifactId>
		<version>1.3.0</version>
		</dependency>

		<dependency>
		<groupId>com.jcraft</groupId>
		<artifactId>jzlib</artifactId>
		<version>1.1.3</version>
		<scope>compile</scope>
		<groupId>io.netty</groupId>
		<artifactId>netty-all</artifactId>
		<version>4.0.33.Final</version>
		</dependency>

		<dependency>
		<groupId>org.javassist</groupId>
		<artifactId>javassist</artifactId>
		<version>3.19.0-GA</version>
		<scope>compile</scope>
		</dependency>

		<dependency>
		<groupId>commons-logging</groupId>
		<artifactId>commons-logging</artifactId>
		<version>1.1.3</version>
		<scope>compile</scope>
		</dependency>

		<dependency>
		<groupId>org.osgi</groupId>
		<artifactId>org.osgi.core</artifactId>
		<version>4.3.1</version>
		<groupId>org.apache.logging.log4j</groupId>
		<artifactId>log4j-core</artifactId>
		<version>2.4.1</version>
		<scope>provided</scope>
		</dependency>

		<dependency>
		<groupId>log4j</groupId>
		<artifactId>log4j</artifactId>
		<version>1.2.17</version>
		<exclusions>
		<exclusion>
		<artifactId>mail</artifactId>
		<groupId>javax.mail</groupId>
		</exclusion>
		<exclusion>
		<artifactId>jms</artifactId>
		<groupId>javax.jms</groupId>
		</exclusion>
		<exclusion>
		<artifactId>jmxtools</artifactId>
		<groupId>com.sun.jdmk</groupId>
		</exclusion>
		<exclusion>
		<artifactId>jmxri</artifactId>
		<groupId>com.sun.jmx</groupId>
		</exclusion>
		</exclusions>
		<scope>compile</scope>
		<optional>true</optional>
		</dependency>

		<dependency>
		<groupId>org.slf4j</groupId>
		<artifactId>slf4j-api</artifactId>
		<version>1.7.5</version>
		<scope>compile</scope>
		</dependency>

		<dependency>
		<groupId>junit</groupId>
		<artifactId>junit</artifactId>
		@@ -132,6 +88,36 @@
		</execution>
		</executions>
		</plugin>
		<!-- Shade the net.bytebuddy/io.netty dependency. -->
		<plugin>
		<groupId>org.apache.maven.plugins</groupId>
		<artifactId>maven-shade-plugin</artifactId>
		<version>${version.plugin.shade}</version>
		<executions>
		<execution>
		<phase>package</phase>
		<goals>
		<goal>shade</goal>
		</goals>
		<configuration>
		<shadedArtifactAttached>false</shadedArtifactAttached>
		<createDependencyReducedPom>true</createDependencyReducedPom>
		<createSourcesJar>true</createSourcesJar>
		<shadeSourcesContent>true</shadeSourcesContent>
		<relocations>
		<relocation>
		<pattern>${shade.net.bytebuddy.source}</pattern>
		<shadedPattern>${shade.net.bytebuddy.target}</shadedPattern>
		</relocation>
		<relocation>
		<pattern>${shade.io.netty.source}</pattern>
		<shadedPattern>${shade.io.netty.target}</shadedPattern>
		</relocation>
		</relocations>
		</configuration>
		</execution>
		</executions>
		</plugin>
		</plugins>
		</build>
		</project>

skywalking-api/src/main/java/com/ai/cloud/io/netty/bootstrap/AbstractBootstrap.java

deleted100755 → 0

+0 −487

Original line number	Diff line number	Diff line
		/*
		* Copyright 2012 The Netty Project
		*
		* The Netty Project licenses this file to you under the Apache License,
		* version 2.0 (the "License"); you may not use this file except in compliance
		* with the License. You may obtain a copy of the License at:
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
		* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
		* License for the specific language governing permissions and limitations
		* under the License.
		*/

		package com.ai.cloud.io.netty.bootstrap;

		import java.net.InetAddress;
		import java.net.InetSocketAddress;
		import java.net.SocketAddress;
		import java.util.LinkedHashMap;
		import java.util.Map;

		import com.ai.cloud.io.netty.channel.Channel;
		import com.ai.cloud.io.netty.channel.ChannelException;
		import com.ai.cloud.io.netty.channel.ChannelFuture;
		import com.ai.cloud.io.netty.channel.ChannelFutureListener;
		import com.ai.cloud.io.netty.channel.ChannelHandler;
		import com.ai.cloud.io.netty.channel.ChannelOption;
		import com.ai.cloud.io.netty.channel.ChannelPromise;
		import com.ai.cloud.io.netty.channel.DefaultChannelPromise;
		import com.ai.cloud.io.netty.channel.EventLoop;
		import com.ai.cloud.io.netty.channel.EventLoopGroup;
		import com.ai.cloud.io.netty.util.AttributeKey;
		import com.ai.cloud.io.netty.util.concurrent.EventExecutor;
		import com.ai.cloud.io.netty.util.concurrent.GlobalEventExecutor;
		import com.ai.cloud.io.netty.util.internal.StringUtil;

		/**
		* {@link AbstractBootstrap} is a helper class that makes it easy to bootstrap a {@link Channel}. It support
		* method-chaining to provide an easy way to configure the {@link AbstractBootstrap}.
		*
		* <p>When not used in a {@link ServerBootstrap} context, the {@link #bind()} methods are useful for connectionless
		* transports such as datagram (UDP).</p>
		*/
		public abstract class AbstractBootstrap<B extends AbstractBootstrap<B, C>, C extends Channel> implements Cloneable {

		volatile EventLoopGroup group;
		private volatile ChannelFactory<? extends C> channelFactory;
		private volatile SocketAddress localAddress;
		private final Map<ChannelOption<?>, Object> options = new LinkedHashMap<ChannelOption<?>, Object>();
		private final Map<AttributeKey<?>, Object> attrs = new LinkedHashMap<AttributeKey<?>, Object>();
		private volatile ChannelHandler handler;

		AbstractBootstrap() {
		// Disallow extending from a different package.
		}

		AbstractBootstrap(AbstractBootstrap<B, C> bootstrap) {
		group = bootstrap.group;
		channelFactory = bootstrap.channelFactory;
		handler = bootstrap.handler;
		localAddress = bootstrap.localAddress;
		synchronized (bootstrap.options) {
		options.putAll(bootstrap.options);
		}
		synchronized (bootstrap.attrs) {
		attrs.putAll(bootstrap.attrs);
		}
		}

		/**
		* The {@link EventLoopGroup} which is used to handle all the events for the to-be-created
		* {@link Channel}
		*/
		@SuppressWarnings("unchecked")
		public B group(EventLoopGroup group) {
		if (group == null) {
		throw new NullPointerException("group");
		}
		if (this.group != null) {
		throw new IllegalStateException("group set already");
		}
		this.group = group;
		return (B) this;
		}

		/**
		* The {@link Class} which is used to create {@link Channel} instances from.
		* You either use this or {@link #channelFactory(ChannelFactory)} if your
		* {@link Channel} implementation has no no-args constructor.
		*/
		public B channel(Class<? extends C> channelClass) {
		if (channelClass == null) {
		throw new NullPointerException("channelClass");
		}
		return channelFactory(new BootstrapChannelFactory<C>(channelClass));
		}

		/**
		* {@link ChannelFactory} which is used to create {@link Channel} instances from
		* when calling {@link #bind()}. This method is usually only used if {@link #channel(Class)}
		* is not working for you because of some more complex needs. If your {@link Channel} implementation
		* has a no-args constructor, its highly recommend to just use {@link #channel(Class)} for
		* simplify your code.
		*/
		@SuppressWarnings("unchecked")
		public B channelFactory(ChannelFactory<? extends C> channelFactory) {
		if (channelFactory == null) {
		throw new NullPointerException("channelFactory");
		}
		if (this.channelFactory != null) {
		throw new IllegalStateException("channelFactory set already");
		}

		this.channelFactory = channelFactory;
		return (B) this;
		}

		/**
		* The {@link SocketAddress} which is used to bind the local "end" to.
		*
		*/
		@SuppressWarnings("unchecked")
		public B localAddress(SocketAddress localAddress) {
		this.localAddress = localAddress;
		return (B) this;
		}

		/**
		* @see {@link #localAddress(SocketAddress)}
		*/
		public B localAddress(int inetPort) {
		return localAddress(new InetSocketAddress(inetPort));
		}

		/**
		* @see {@link #localAddress(SocketAddress)}
		*/
		public B localAddress(String inetHost, int inetPort) {
		return localAddress(new InetSocketAddress(inetHost, inetPort));
		}

		/**
		* @see {@link #localAddress(SocketAddress)}
		*/
		public B localAddress(InetAddress inetHost, int inetPort) {
		return localAddress(new InetSocketAddress(inetHost, inetPort));
		}

		/**
		* Allow to specify a {@link ChannelOption} which is used for the {@link Channel} instances once they got
		* created. Use a value of {@code null} to remove a previous set {@link ChannelOption}.
		*/
		@SuppressWarnings("unchecked")
		public <T> B option(ChannelOption<T> option, T value) {
		if (option == null) {
		throw new NullPointerException("option");
		}
		if (value == null) {
		synchronized (options) {
		options.remove(option);
		}
		} else {
		synchronized (options) {
		options.put(option, value);
		}
		}
		return (B) this;
		}

		/**
		* Allow to specify an initial attribute of the newly created {@link Channel}. If the {@code value} is
		* {@code null}, the attribute of the specified {@code key} is removed.
		*/
		@SuppressWarnings("unchecked")
		public <T> B attr(AttributeKey<T> key, T value) {
		if (key == null) {
		throw new NullPointerException("key");
		}
		if (value == null) {
		synchronized (attrs) {
		attrs.remove(key);
		}
		} else {
		synchronized (attrs) {
		attrs.put(key, value);
		}
		}
		return (B) this;
		}

		/**
		* Validate all the parameters. Sub-classes may override this, but should
		* call the super method in that case.
		*/
		@SuppressWarnings("unchecked")
		public B validate() {
		if (group == null) {
		throw new IllegalStateException("group not set");
		}
		if (channelFactory == null) {
		throw new IllegalStateException("channel or channelFactory not set");
		}
		return (B) this;
		}

		/**
		* Returns a deep clone of this bootstrap which has the identical configuration. This method is useful when making
		* multiple {@link Channel}s with similar settings. Please note that this method does not clone the
		* {@link EventLoopGroup} deeply but shallowly, making the group a shared resource.
		*/
		@Override
		@SuppressWarnings("CloneDoesntDeclareCloneNotSupportedException")
		public abstract B clone();

		/**
		* Create a new {@link Channel} and register it with an {@link EventLoop}.
		*/
		public ChannelFuture register() {
		validate();
		return initAndRegister();
		}

		/**
		* Create a new {@link Channel} and bind it.
		*/
		public ChannelFuture bind() {
		validate();
		SocketAddress localAddress = this.localAddress;
		if (localAddress == null) {
		throw new IllegalStateException("localAddress not set");
		}
		return doBind(localAddress);
		}

		/**
		* Create a new {@link Channel} and bind it.
		*/
		public ChannelFuture bind(int inetPort) {
		return bind(new InetSocketAddress(inetPort));
		}

		/**
		* Create a new {@link Channel} and bind it.
		*/
		public ChannelFuture bind(String inetHost, int inetPort) {
		return bind(new InetSocketAddress(inetHost, inetPort));
		}

		/**
		* Create a new {@link Channel} and bind it.
		*/
		public ChannelFuture bind(InetAddress inetHost, int inetPort) {
		return bind(new InetSocketAddress(inetHost, inetPort));
		}

		/**
		* Create a new {@link Channel} and bind it.
		*/
		public ChannelFuture bind(SocketAddress localAddress) {
		validate();
		if (localAddress == null) {
		throw new NullPointerException("localAddress");
		}
		return doBind(localAddress);
		}

		private ChannelFuture doBind(final SocketAddress localAddress) {
		final ChannelFuture regFuture = initAndRegister();
		final Channel channel = regFuture.channel();
		if (regFuture.cause() != null) {
		return regFuture;
		}

		if (regFuture.isDone()) {
		// At this point we know that the registration was complete and successful.
		ChannelPromise promise = channel.newPromise();
		doBind0(regFuture, channel, localAddress, promise);
		return promise;
		} else {
		// Registration future is almost always fulfilled already, but just in case it's not.
		final PendingRegistrationPromise promise = new PendingRegistrationPromise(channel);
		regFuture.addListener(new ChannelFutureListener() {
		@Override
		public void operationComplete(ChannelFuture future) throws Exception {
		Throwable cause = future.cause();
		if (cause != null) {
		// Registration on the EventLoop failed so fail the ChannelPromise directly to not cause an
		// IllegalStateException once we try to access the EventLoop of the Channel.
		promise.setFailure(cause);
		} else {
		// Registration was successful, so set the correct executor to use.
		// See https://github.com/netty/netty/issues/2586
		promise.executor = channel.eventLoop();
		}
		doBind0(regFuture, channel, localAddress, promise);
		}
		});
		return promise;
		}
		}

		final ChannelFuture initAndRegister() {
		final Channel channel = channelFactory().newChannel();
		try {
		init(channel);
		} catch (Throwable t) {
		channel.unsafe().closeForcibly();
		// as the Channel is not registered yet we need to force the usage of the GlobalEventExecutor
		return new DefaultChannelPromise(channel, GlobalEventExecutor.INSTANCE).setFailure(t);
		}

		ChannelFuture regFuture = group().register(channel);
		if (regFuture.cause() != null) {
		if (channel.isRegistered()) {
		channel.close();
		} else {
		channel.unsafe().closeForcibly();
		}
		}

		// If we are here and the promise is not failed, it's one of the following cases:
		// 1) If we attempted registration from the event loop, the registration has been completed at this point.
		// i.e. It's safe to attempt bind() or connect() now because the channel has been registered.
		// 2) If we attempted registration from the other thread, the registration request has been successfully
		// added to the event loop's task queue for later execution.
		// i.e. It's safe to attempt bind() or connect() now:
		// because bind() or connect() will be executed after the scheduled registration task is executed
		// because register(), bind(), and connect() are all bound to the same thread.

		return regFuture;
		}

		abstract void init(Channel channel) throws Exception;

		private static void doBind0(
		final ChannelFuture regFuture, final Channel channel,
		final SocketAddress localAddress, final ChannelPromise promise) {

		// This method is invoked before channelRegistered() is triggered. Give user handlers a chance to set up
		// the pipeline in its channelRegistered() implementation.
		channel.eventLoop().execute(new Runnable() {
		@Override
		public void run() {
		if (regFuture.isSuccess()) {
		channel.bind(localAddress, promise).addListener(ChannelFutureListener.CLOSE_ON_FAILURE);
		} else {
		promise.setFailure(regFuture.cause());
		}
		}
		});
		}

		/**
		* the {@link ChannelHandler} to use for serving the requests.
		*/
		@SuppressWarnings("unchecked")
		public B handler(ChannelHandler handler) {
		if (handler == null) {
		throw new NullPointerException("handler");
		}
		this.handler = handler;
		return (B) this;
		}

		final SocketAddress localAddress() {
		return localAddress;
		}

		final ChannelFactory<? extends C> channelFactory() {
		return channelFactory;
		}

		final ChannelHandler handler() {
		return handler;
		}

		/**
		* Return the configured {@link EventLoopGroup} or {@code null} if non is configured yet.
		*/
		public EventLoopGroup group() {
		return group;
		}

		final Map<ChannelOption<?>, Object> options() {
		return options;
		}

		final Map<AttributeKey<?>, Object> attrs() {
		return attrs;
		}

		@Override
		public String toString() {
		StringBuilder buf = new StringBuilder()
		.append(StringUtil.simpleClassName(this))
		.append('(');
		if (group != null) {
		buf.append("group: ")
		.append(StringUtil.simpleClassName(group))
		.append(", ");
		}
		if (channelFactory != null) {
		buf.append("channelFactory: ")
		.append(channelFactory)
		.append(", ");
		}
		if (localAddress != null) {
		buf.append("localAddress: ")
		.append(localAddress)
		.append(", ");
		}
		synchronized (options) {
		if (!options.isEmpty()) {
		buf.append("options: ")
		.append(options)
		.append(", ");
		}
		}
		synchronized (attrs) {
		if (!attrs.isEmpty()) {
		buf.append("attrs: ")
		.append(attrs)
		.append(", ");
		}
		}
		if (handler != null) {
		buf.append("handler: ")
		.append(handler)
		.append(", ");
		}
		if (buf.charAt(buf.length() - 1) == '(') {
		buf.append(')');
		} else {
		buf.setCharAt(buf.length() - 2, ')');
		buf.setLength(buf.length() - 1);
		}
		return buf.toString();
		}

		private static final class BootstrapChannelFactory<T extends Channel> implements ChannelFactory<T> {
		private final Class<? extends T> clazz;

		BootstrapChannelFactory(Class<? extends T> clazz) {
		this.clazz = clazz;
		}

		@Override
		public T newChannel() {
		try {
		return clazz.newInstance();
		} catch (Throwable t) {
		throw new ChannelException("Unable to create Channel from class " + clazz, t);
		}
		}

		@Override
		public String toString() {
		return StringUtil.simpleClassName(clazz) + ".class";
		}
		}

		private static final class PendingRegistrationPromise extends DefaultChannelPromise {
		// Is set to the correct EventExecutor once the registration was successful. Otherwise it will
		// stay null and so the GlobalEventExecutor.INSTANCE will be used for notifications.
		private volatile EventExecutor executor;

		private PendingRegistrationPromise(Channel channel) {
		super(channel);
		}

		@Override
		protected EventExecutor executor() {
		EventExecutor executor = this.executor;
		if (executor != null) {
		// If the registration was a success executor is set.
		//
		// See https://github.com/netty/netty/issues/2586
		return executor;
		}
		// The registration failed so we can only use the GlobalEventExecutor as last resort to notify.
		return GlobalEventExecutor.INSTANCE;
		}
		}
		}

skywalking-api/src/main/java/com/ai/cloud/io/netty/bootstrap/Bootstrap.java

deleted100755 → 0

+0 −245

File deleted.

Preview size limit exceeded, changes collapsed.

skywalking-api/src/main/java/com/ai/cloud/io/netty/bootstrap/ChannelFactory.java

deleted100755 → 0

+0 −29

Original line number	Diff line number	Diff line
		/*
		* Copyright 2013 The Netty Project
		*
		* The Netty Project licenses this file to you under the Apache License,
		* version 2.0 (the "License"); you may not use this file except in compliance
		* with the License. You may obtain a copy of the License at:
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
		* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
		* License for the specific language governing permissions and limitations
		* under the License.
		*/
		package com.ai.cloud.io.netty.bootstrap;

		import com.ai.cloud.io.netty.channel.Channel;

		/**
		* Factory that creates a new {@link Channel} on {@link Bootstrap#bind()}, {@link Bootstrap#connect()}, and
		* {@link ServerBootstrap#bind()}.
		*/
		public interface ChannelFactory<T extends Channel> {
		/**
		* Creates a new channel.
		*/
		T newChannel();
		}

skywalking-api/src/main/java/com/ai/cloud/io/netty/bootstrap/ServerBootstrap.java

deleted100755 → 0

+0 −334

File deleted.

Preview size limit exceeded, changes collapsed.