001    /**
002     *  Licensed to the Apache Software Foundation (ASF) under one or more
003     *  contributor license agreements.  See the NOTICE file distributed with
004     *  this work for additional information regarding copyright ownership.
005     *  The ASF licenses this file to You under the Apache License, Version 2.0
006     *  (the "License"); you may not use this file except in compliance with
007     *  the License.  You may obtain a copy of the License at
008     *
009     *     http://www.apache.org/licenses/LICENSE-2.0
010     *
011     *  Unless required by applicable law or agreed to in writing, software
012     *  distributed under the License is distributed on an "AS IS" BASIS,
013     *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014     *  See the License for the specific language governing permissions and
015     *  limitations under the License.
016     */
017    package org.apache.geronimo.gbean.runtime;
018    
019    import org.apache.commons.logging.Log;
020    import org.apache.commons.logging.LogFactory;
021    import org.apache.geronimo.gbean.AbstractName;
022    import org.apache.geronimo.gbean.AbstractNameQuery;
023    import org.apache.geronimo.gbean.InvalidConfigurationException;
024    import org.apache.geronimo.kernel.GBeanNotFoundException;
025    import org.apache.geronimo.kernel.Kernel;
026    import org.apache.geronimo.kernel.lifecycle.LifecycleAdapter;
027    import org.apache.geronimo.kernel.lifecycle.LifecycleListener;
028    import org.apache.geronimo.kernel.management.State;
029    
030    /**
031     * @version $Rev: 476049 $ $Date: 2006-11-16 23:35:17 -0500 (Thu, 16 Nov 2006) $
032     */
033    public final class GBeanDependency {
034    
035    
036        private static final Log log = LogFactory.getLog(GBeanDependency.class);
037    
038        /**
039         * The GBeanInstance to which this reference belongs.
040         */
041        private final GBeanInstance gbeanInstance;
042    
043        /**
044         * The target objectName targetName to watch for a connection.
045         */
046        private final AbstractName targetName;
047    
048        /**
049         * Our listener for lifecycle events
050         */
051        private final LifecycleListener listener;
052    
053        /**
054         * The kernel to which the reference is bound.
055         */
056        private final Kernel kernel;
057    
058        private boolean targetRunning = false;
059        private boolean dependencyRegistered = false;
060    
061        public GBeanDependency(GBeanInstance gbeanInstance, AbstractName targetName, Kernel kernel) throws InvalidConfigurationException {
062            this.gbeanInstance = gbeanInstance;
063            this.kernel = kernel;
064            this.targetName = targetName;
065            listener = createLifecycleListener();
066        }
067    
068        public AbstractName getTargetName() {
069            return targetName;
070        }
071    
072        public final synchronized void online() {
073            //TODO consider including interfaces in query
074            AbstractNameQuery query = new AbstractNameQuery(targetName, null);
075            kernel.getLifecycleMonitor().addLifecycleListener(listener, query);
076            targetRunning = isRunning(kernel, targetName);
077        }
078    
079        public synchronized boolean start() {
080            if (targetRunning && !dependencyRegistered) {
081                AbstractName abstractName = gbeanInstance.getAbstractName();
082                kernel.getDependencyManager().addDependency(abstractName, targetName);
083                dependencyRegistered = true;
084            }
085            return targetRunning;
086        }
087    
088    
089        public synchronized void stop() {
090            if (dependencyRegistered) {
091                AbstractName abstractName = gbeanInstance.getAbstractName();
092                kernel.getDependencyManager().removeDependency(abstractName, targetName);
093                dependencyRegistered = false;
094            }
095        }
096    
097        public final synchronized void offline() {
098            // make sure we are stopped
099            stop();
100    
101            kernel.getLifecycleMonitor().removeLifecycleListener(listener);
102            targetRunning = false;
103        }
104    
105        private synchronized void attemptFullStart() {
106            try {
107                // there could be an issue with really badly written components holding up a stop when the
108                // component never reached the starting phase... then a target registers and we automatically
109                // attempt to restart
110    //            waitingForMe = false;
111                gbeanInstance.start();
112            } catch (Exception e) {
113                log.warn("Exception occured while attempting to fully start: objectName=" + gbeanInstance.getObjectName(), e);
114            }
115        }
116    
117        protected LifecycleListener createLifecycleListener() {
118            return new LifecycleAdapter() {
119                public void running(AbstractName abstractName) {
120                    addTarget(abstractName);
121                }
122    
123                public void stopped(AbstractName abstractName) {
124                    removeTarget(abstractName);
125                }
126    
127                public void failed(AbstractName abstractName) {
128                    removeTarget(abstractName);
129                }
130    
131                public void unloaded(AbstractName abstractName) {
132                    removeTarget(abstractName);
133                }
134            };
135        }
136    
137        protected final void addTarget(AbstractName abstractName) {
138            // if we are running, and we now have two valid targets, which is an illegal state so we need to fail
139            synchronized (this) {
140                targetRunning = true;
141                GBeanInstance gbeanInstance1 = gbeanInstance;
142                if (gbeanInstance1.getStateInstance() == State.RUNNING) {
143                    log.error("Illegal state: two or more targets are running for a dependency: " + getDescription() +
144                            ",\n    newTarget=" + abstractName);
145                }
146                attemptFullStart();
147            }
148        }
149    
150        protected final void removeTarget(AbstractName abstractName) {
151            synchronized (this) {
152                targetRunning = false;
153                GBeanInstance gbeanInstance1 = gbeanInstance;
154                if (gbeanInstance1.getStateInstance() == State.RUNNING) {
155                    // we no longer have a valid target, which is an illegal state so we need to fail
156                    log.error("Illegal state: current target for a single valued reference stopped: " + getDescription() +
157                            ",\n    stopped Target=" + abstractName);
158                    gbeanInstance1.referenceFailed();
159                }
160            }
161        }
162    
163    
164        /**
165         * Is the component in the Running state
166         *
167         * @param objectName name of the component to check
168         * @return true if the component is running; false otherwise
169         */
170        private boolean isRunning(Kernel kernel, AbstractName objectName) {
171            try {
172                final int state = kernel.getGBeanState(objectName);
173                return state == State.RUNNING_INDEX;
174            } catch (GBeanNotFoundException e) {
175                // gbean is no longer registerd
176                return false;
177            } catch (Exception e) {
178                // problem getting the attribute, gbean has most likely failed
179                return false;
180            }
181        }
182    
183        protected final String getDescription() {
184            return "\n    GBeanInstance: " + gbeanInstance.getName() +
185                    "\n    Target Name: " + targetName;
186        }
187    
188        public boolean equals(Object o) {
189            if (this == o) return true;
190            if (o == null || getClass() != o.getClass()) return false;
191    
192            final GBeanDependency that = (GBeanDependency) o;
193    
194            if (gbeanInstance != null ? !gbeanInstance.equals(that.gbeanInstance) : that.gbeanInstance != null) {
195                return false;
196            }
197            return !(targetName != null ? !targetName.equals(that.targetName) : that.targetName != null);
198    
199        }
200    
201        public int hashCode() {
202            int result;
203            result = (gbeanInstance != null ? gbeanInstance.hashCode() : 0);
204            result = 29 * result + (targetName != null ? targetName.hashCode() : 0);
205            return result;
206        }
207    }