View Javadoc

    1   /*
    2    *  Licensed to the Apache Software Foundation (ASF) under one
    3    *  or more contributor license agreements.  See the NOTICE file
    4    *  distributed with this work for additional information
    5    *  regarding copyright ownership.  The ASF licenses this file
    6    *  to you under the Apache License, Version 2.0 (the
    7    *  "License"); you may not use this file except in compliance
    8    *  with the License.  You may obtain a copy of the License at
    9    *
    10   *    http://www.apache.org/licenses/LICENSE-2.0
    11   *
    12   *  Unless required by applicable law or agreed to in writing,
    13   *  software distributed under the License is distributed on an
    14   *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
    15   *  KIND, either express or implied.  See the License for the
    16   *  specific language governing permissions and limitations
    17   *  under the License.
    18   *
    19   */
    20  package org.apache.mina.service;
    21
    22  import java.util.Map;
    23  import java.util.concurrent.ConcurrentHashMap;
    24
    25  import org.apache.mina.api.IoFilter;
    26  import org.apache.mina.api.IoHandler;
    27  import org.apache.mina.api.IoService;
    28  import org.apache.mina.api.IoSession;
    29  import org.apache.mina.api.IoSessionConfig;
    30  import org.apache.mina.service.executor.IoHandlerExecutor;
    31  import org.slf4j.Logger;
    32  import org.slf4j.LoggerFactory;
    33
    34  /**
    35   * Base implementation for {@link IoService}s.
    36   *
    37   * @author <a href="http://mina.apache.org">Apache MINA Project</a>
    38   */
    39  public abstract class AbstractIoService implements IoService {
    40
    41      /** A logger for this class */
    42      static final Logger LOG = LoggerFactory.getLogger(AbstractIoService.class);
    43
    44      /** The service state */
    45      private ServiceState state;
    46
    47      /** The placeholder of managed open sessions */
    48      private final Map<Long, IoSession> managedSessions = new ConcurrentHashMap<Long, IoSession>();
    49
    50      /** the default session configuration */
    51      protected IoSessionConfig config;
    52
    53      /** The high level business logic */
    54      private IoHandler handler;
    55
    56      /** Filters chain */
    57      private IoFilter[] filters = new IoFilter[0];
    58
    59      /** used for executing IoHandler event in another pool of thread (not in the low level I/O one) */
    60      protected final IoHandlerExecutor ioHandlerExecutor;
    61
    62      /**
    63       * The Service states
    64       */
    65      protected enum ServiceState {
    66          /** Initial state */
    67          NONE,
    68          /** The service has been created */
    69          CREATED,
    70          /** The service is started */
    71          ACTIVE,
    72          /** The service has been suspended */
    73          SUSPENDED,
    74          /** The service is being stopped */
    75          DISPOSING,
    76          /** The service is stopped */
    77          DISPOSED
    78      }
    79
    80      /**
    81       * Create an AbstractIoService
    82       *
    83       * @param eventExecutor used for executing IoHandler event in another pool of thread (not in the low level I/O one).
    84       *        Use <code>null</code> if you don't want one. Be careful, the IoHandler processing will block the I/O
    85       *        operations.
    86       */
    87      protected AbstractIoService(final IoHandlerExecutor eventExecutor) {
    88          this.state = ServiceState.NONE;
    89          this.ioHandlerExecutor = eventExecutor;
    90      }
    91
    92      /**
    93       * {@inheritDoc}
    94       */
    95      @Override
    96      public Map<Long, IoSession> getManagedSessions() {
    97          return this.managedSessions;
    98      }
    99
    100     /**
    101      * {@inheritDoc}
    102      */
    103     @Override
    104     public void setIoHandler(final IoHandler handler) {
    105         this.handler = handler;
    106     }
    107
    108     /**
    109      * {@inheritDoc}
    110      */
    111     @Override
    112     public IoHandler getIoHandler() {
    113         return handler;
    114     }
    115
    116     /**
    117      * {@inheritDoc}
    118      */
    119     @Override
    120     public IoHandlerExecutor getIoHandlerExecutor() {
    121         return ioHandlerExecutor;
    122     }
    123
    124     /**
    125      * @return true if the IoService is active
    126      */
    127     public boolean isActive() {
    128         return this.state == ServiceState.ACTIVE;
    129     }
    130
    131     /**
    132      * @return true if the IoService is being disposed
    133      */
    134     public boolean isDisposing() {
    135         return this.state == ServiceState.DISPOSING;
    136     }
    137
    138     /**
    139      * @return true if the IoService is disposed
    140      */
    141     public boolean isDisposed() {
    142         return this.state == ServiceState.DISPOSED;
    143     }
    144
    145     /**
    146      * @return true if the IoService is suspended
    147      */
    148     public boolean isSuspended() {
    149         return this.state == ServiceState.SUSPENDED;
    150     }
    151
    152     /**
    153      * @return true if the IoService is created
    154      */
    155     public boolean isCreated() {
    156         return this.state == ServiceState.CREATED;
    157     }
    158
    159     /**
    160      * Sets the IoService state to CREATED.
    161      */
    162     protected void setCreated() {
    163         this.state = ServiceState.CREATED;
    164     }
    165
    166     /**
    167      * Sets the IoService state to ACTIVE.
    168      */
    169     protected void setActive() {
    170         this.state = ServiceState.ACTIVE;
    171     }
    172
    173     /**
    174      * Sets the IoService state to DISPOSED.
    175      */
    176     protected void setDisposed() {
    177         this.state = ServiceState.DISPOSED;
    178     }
    179
    180     /**
    181      * Sets the IoService state to DISPOSING.
    182      */
    183     protected void setDisposing() {
    184         this.state = ServiceState.DISPOSING;
    185     }
    186
    187     /**
    188      * Sets the IoService state to SUSPENDED.
    189      */
    190     protected void setSuspended() {
    191         this.state = ServiceState.SUSPENDED;
    192     }
    193
    194     /**
    195      * Initialize the IoService state
    196      */
    197     protected void initState() {
    198         this.state = ServiceState.NONE;
    199     }
    200
    201     /**
    202      * Inform all current the listeners of the service activation.
    203      */
    204     protected void fireServiceActivated() {
    205         if (handler != null) {
    206             handler.serviceActivated(this);
    207         }
    208     }
    209
    210     /**
    211      * Inform all current the listeners of the service desactivation.
    212      */
    213     protected void fireServiceInactivated() {
    214         if (handler != null) {
    215             handler.serviceInactivated(this);
    216         }
    217     }
    218
    219     /**
    220      * {@inheritDoc}
    221      */
    222     @Override
    223     public IoFilter[] getFilters() {
    224         return this.filters;
    225     }
    226
    227     /**
    228      * {@inheritDoc}
    229      */
    230     @Override
    231     public void setFilters(final IoFilter... filters) {
    232         this.filters = filters;
    233     }
    234 }