#19702

/*
 * Copyright 2021 The gRPC Authors
 *
 * Licensed 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 io.grpc.xds;

import com.google.common.base.MoreObjects;
import com.google.protobuf.Message;
import io.grpc.ClientInterceptor;
import io.grpc.ServerInterceptor;
import java.util.Objects;
import java.util.concurrent.ScheduledExecutorService;
import javax.annotation.Nullable;

/**
 * Defines the parsing functionality of an HTTP filter.
 *
 * <p>A Filter may optionally implement either {@link Filter#buildClientInterceptor} or
 * {@link Filter#buildServerInterceptor} or both, and return true from corresponding
 * {@link Provider#isClientFilter()}, {@link Provider#isServerFilter()} to indicate that the filter
 * is capable of working on the client side or server side or both, respectively.
 */
interface Filter {

  /** Represents an opaque data structure holding configuration for a filter. */
  interface FilterConfig {
    String typeUrl();
  }

  /**
   * Common interface for filter providers.
   */
  interface Provider {
    /**
     * The proto message types supported by this filter. A filter will be registered by each of its
     * supported message types.
     */
    String[] typeUrls();

    /**
     * Whether the filter can be installed on the client side.
     *
     * <p>Returns true if the filter implements {@link Filter#buildClientInterceptor}.
     */
    default boolean isClientFilter() {
      return false;
    }

    /**
     * Whether the filter can be installed into xDS-enabled servers.
     *
     * <p>Returns true if the filter implements {@link Filter#buildServerInterceptor}.
     */
    default boolean isServerFilter() {
      return false;
    }

    /**
     * Creates a new instance of the filter.
     *
     * <p>Returns a filter instance registered with the same typeUrls as the provider,
     * capable of working with the same FilterConfig type returned by provider's parse functions.
     */
    Filter newInstance();

    /**
     * Parses the top-level filter config from raw proto message. The message may be either a {@link
     * com.google.protobuf.Any} or a {@link com.google.protobuf.Struct}.
     */
    ConfigOrError<? extends FilterConfig> parseFilterConfig(Message rawProtoMessage);

    /**
     * Parses the per-filter override filter config from raw proto message. The message may be
     * either a {@link com.google.protobuf.Any} or a {@link com.google.protobuf.Struct}.
     */
    ConfigOrError<? extends FilterConfig> parseFilterConfigOverride(Message rawProtoMessage);
  }

  /** Uses the FilterConfigs produced above to produce an HTTP filter interceptor for clients. */
  @Nullable
  default ClientInterceptor buildClientInterceptor(
      FilterConfig config, @Nullable FilterConfig overrideConfig,
      ScheduledExecutorService scheduler) {
    return null;
  }

  /** Uses the FilterConfigs produced above to produce an HTTP filter interceptor for the server. */
  @Nullable
  default ServerInterceptor buildServerInterceptor(
      FilterConfig config, @Nullable FilterConfig overrideConfig) {
    return null;
  }

  /** Filter config with instance name. */
  final class NamedFilterConfig {
    // filter instance name
    final String name;
    final FilterConfig filterConfig;

    NamedFilterConfig(String name, FilterConfig filterConfig) {
      this.name = name;
      this.filterConfig = filterConfig;
    }

    @Override
    public boolean equals(Object o) {
      if (this == o) {
        return true;
      }
      if (o == null || getClass() != o.getClass()) {
        return false;
      }
      NamedFilterConfig that = (NamedFilterConfig) o;
      return Objects.equals(name, that.name)
          && Objects.equals(filterConfig, that.filterConfig);
    }

    @Override
    public int hashCode() {
      return Objects.hash(name, filterConfig);
    }

    @Override
    public String toString() {
      return MoreObjects.toStringHelper(this)
          .add("name", name)
          .add("filterConfig", filterConfig)
          .toString();
    }
  }
}

1	/*
2	* Copyright 2021 The gRPC Authors
3	*
4	* Licensed under the Apache License, Version 2.0 (the "License");
5	* you may not use this file except in compliance with the License.
6	* You may obtain a copy of the License at
7	*
8	* http://www.apache.org/licenses/LICENSE-2.0
9	*
10	* Unless required by applicable law or agreed to in writing, software
11	* distributed under the License is distributed on an "AS IS" BASIS,
12	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13	* See the License for the specific language governing permissions and
14	* limitations under the License.
15	*/
16
17	package io.grpc.xds;
18
19	import com.google.common.base.MoreObjects;
20	import com.google.protobuf.Message;
21	import io.grpc.ClientInterceptor;
22	import io.grpc.ServerInterceptor;
23	import java.util.Objects;
24	import java.util.concurrent.ScheduledExecutorService;
25	import javax.annotation.Nullable;
26
27	/**
28	* Defines the parsing functionality of an HTTP filter.
29	*
30	* <p>A Filter may optionally implement either {@link Filter#buildClientInterceptor} or
31	* {@link Filter#buildServerInterceptor} or both, and return true from corresponding
32	* {@link Provider#isClientFilter()}, {@link Provider#isServerFilter()} to indicate that the filter
33	* is capable of working on the client side or server side or both, respectively.
34	*/
35	interface Filter {
36
37	/** Represents an opaque data structure holding configuration for a filter. */
38	interface FilterConfig {
39	String typeUrl();
40	}
41
42	/**
43	* Common interface for filter providers.
44	*/
45	interface Provider {
46	/**
47	* The proto message types supported by this filter. A filter will be registered by each of its
48	* supported message types.
49	*/
50	String[] typeUrls();
51
52	/**
53	* Whether the filter can be installed on the client side.
54	*
55	* <p>Returns true if the filter implements {@link Filter#buildClientInterceptor}.
56	*/
57	default boolean isClientFilter() {
58	return false;	1✔
59	}
60
61	/**
62	* Whether the filter can be installed into xDS-enabled servers.
63	*
64	* <p>Returns true if the filter implements {@link Filter#buildServerInterceptor}.
65	*/
66	default boolean isServerFilter() {
67	return false;	1✔
68	}
69
70	/**
71	* Creates a new instance of the filter.
72	*
73	* <p>Returns a filter instance registered with the same typeUrls as the provider,
74	* capable of working with the same FilterConfig type returned by provider's parse functions.
75	*/
76	Filter newInstance();
77
78	/**
79	* Parses the top-level filter config from raw proto message. The message may be either a {@link
80	* com.google.protobuf.Any} or a {@link com.google.protobuf.Struct}.
81	*/
82	ConfigOrError<? extends FilterConfig> parseFilterConfig(Message rawProtoMessage);
83
84	/**
85	* Parses the per-filter override filter config from raw proto message. The message may be
86	* either a {@link com.google.protobuf.Any} or a {@link com.google.protobuf.Struct}.
87	*/
88	ConfigOrError<? extends FilterConfig> parseFilterConfigOverride(Message rawProtoMessage);
89	}
90
91	/** Uses the FilterConfigs produced above to produce an HTTP filter interceptor for clients. */
92	@Nullable
93	default ClientInterceptor buildClientInterceptor(
94	FilterConfig config, @Nullable FilterConfig overrideConfig,
95	ScheduledExecutorService scheduler) {
96	return null;	1✔
97	}
98
99	/** Uses the FilterConfigs produced above to produce an HTTP filter interceptor for the server. */
100	@Nullable
101	default ServerInterceptor buildServerInterceptor(
102	FilterConfig config, @Nullable FilterConfig overrideConfig) {
103	return null;	1✔
104	}
105
106	/** Filter config with instance name. */
107	final class NamedFilterConfig {
108	// filter instance name
109	final String name;
110	final FilterConfig filterConfig;
111
112	NamedFilterConfig(String name, FilterConfig filterConfig) {	1✔
113	this.name = name;	1✔
114	this.filterConfig = filterConfig;	1✔
115	}	1✔
116
117	@Override
118	public boolean equals(Object o) {
119	if (this == o) {	1✔
120	return true;	×
121	}
122	if (o == null \|\| getClass() != o.getClass()) {	1✔
123	return false;	×
124	}
125	NamedFilterConfig that = (NamedFilterConfig) o;	1✔
126	return Objects.equals(name, that.name)	1✔
127	&& Objects.equals(filterConfig, that.filterConfig);	1✔
128	}
129
130	@Override
131	public int hashCode() {
132	return Objects.hash(name, filterConfig);	1✔
133	}
134
135	@Override
136	public String toString() {
137	return MoreObjects.toStringHelper(this)	1✔
138	.add("name", name)	1✔
139	.add("filterConfig", filterConfig)	1✔
140	.toString();	1✔
141	}
142	}
143	}

grpc / grpc-java / #19702

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous