← Back to branch summary

~ubuntu-branches/ubuntu/intrepid/tomcat5.5/intrepid

« back to all changes in this revision

Viewing changes to container/modules/groupcom/src/share/org/apache/catalina/tribes/membership/McastMembership.java

  • Committer: Bazaar Package Importer
  • Author(s): Matthias Klose
  • Date: 2006-09-27 11:19:17 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20060927111917-wov6fmkz3x6rsl68
Tags: 5.5.17-1ubuntu1
(Build-) depend on libmx4j-java (>= 3.0).

Show diffs side-by-side

added added

removed removed

Lines of Context:
container/modules/groupcom/src/share/org/apache/catalina/tribes/membership/McastMembership.java
 
1
/*
 
2
 * Copyright 1999,2004 The Apache Software Foundation.
 
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 org.apache.catalina.tribes.membership;
 
18
 
 
19
 
 
20
import java.util.ArrayList;
 
21
import java.util.Arrays;
 
22
import java.util.HashMap;
 
23
import java.util.Iterator;
 
24
import java.util.Map;
 
25
 
 
26
import org.apache.catalina.tribes.Member;
 
27
 
 
28
/**
 
29
 * A <b>membership</b> implementation using simple multicast.
 
30
 * This is the representation of a multicast membership.
 
31
 * This class is responsible for maintaining a list of active cluster nodes in the cluster.
 
32
 * If a node fails to send out a heartbeat, the node will be dismissed.
 
33
 *
 
34
 * @author Filip Hanik
 
35
 * @author Peter Rossbach
 
36
 * @version $Revision: 356540 $, $Date: 2005-12-13 10:53:40 -0600 (Tue, 13 Dec 2005) $
 
37
 */
 
38
public class McastMembership
 
39
{
 
40
    protected static final MemberImpl[] EMPTY_MEMBERS = new MemberImpl[0];
 
41
    
 
42
    /**
 
43
     * The name of this membership, has to be the same as the name for the local
 
44
     * member
 
45
     */
 
46
    protected MemberImpl local;
 
47
    
 
48
    /**
 
49
     * A map of all the members in the cluster.
 
50
     */
 
51
    protected Map map = new HashMap();
 
52
    
 
53
    /**
 
54
     * A list of all the members in the cluster.
 
55
     */
 
56
    protected MemberImpl[] members = EMPTY_MEMBERS;
 
57
    
 
58
    /**
 
59
      * sort members by alive time
 
60
      */
 
61
    protected MemberComparator memberComparator = new MemberComparator();
 
62
 
 
63
    /**
 
64
     * Constructs a new membership
 
65
     * @param name - has to be the name of the local member. Used to filter the local member from the cluster membership
 
66
     */
 
67
    public McastMembership(MemberImpl local) {
 
68
        this.local = local;
 
69
    }
 
70
 
 
71
    /**
 
72
     * Reset the membership and start over fresh.
 
73
     * Ie, delete all the members and wait for them to ping again and join this membership
 
74
     */
 
75
    public synchronized void reset() {
 
76
        map.clear();
 
77
        members = EMPTY_MEMBERS ;
 
78
    }
 
79
 
 
80
    /**
 
81
     * Notify the membership that this member has announced itself.
 
82
     *
 
83
     * @param member - the member that just pinged us
 
84
     * @return - true if this member is new to the cluster, false otherwise.
 
85
     * @return - false if this member is the local member or updated.
 
86
     */
 
87
    public synchronized boolean memberAlive(MemberImpl member) {
 
88
        boolean result = false;
 
89
        //ignore ourselves
 
90
        if (  member.equals(local) ) return result;
 
91
 
 
92
        //return true if the membership has changed
 
93
        MbrEntry entry = (MbrEntry)map.get(member);
 
94
        if ( entry == null ) {
 
95
            entry = new MbrEntry(member);
 
96
            map.put(member,entry);
 
97
            addMcastMember(member);
 
98
            result = true;
 
99
       } else {
 
100
            //update the member alive time
 
101
            MemberImpl updateMember = entry.getMember() ;
 
102
            if(updateMember.getMemberAliveTime() != member.getMemberAliveTime()) {
 
103
                updateMember.setMemberAliveTime(member.getMemberAliveTime());
 
104
                Arrays.sort(members, memberComparator);
 
105
            }
 
106
        }
 
107
        entry.accessed();
 
108
 
 
109
        return result;
 
110
    }
 
111
 
 
112
    /**
 
113
     * Add a member to this component and sort array with memberComparator
 
114
     * @param member The member to add
 
115
     */
 
116
    protected void addMcastMember(MemberImpl member) {
 
117
      synchronized (members) {
 
118
          MemberImpl results[] =
 
119
            new MemberImpl[members.length + 1];
 
120
          for (int i = 0; i < members.length; i++)
 
121
              results[i] = members[i];
 
122
          results[members.length] = member;
 
123
          members = results;
 
124
          Arrays.sort(members, memberComparator);
 
125
      }
 
126
    }
 
127
    
 
128
    /**
 
129
     * Remove a member from this component.
 
130
     * 
 
131
     * @param member The member to remove
 
132
     */
 
133
    protected void removeMcastMember(MemberImpl member) {
 
134
        synchronized (members) {
 
135
            int n = -1;
 
136
            for (int i = 0; i < members.length; i++) {
 
137
                if (members[i] == member) {
 
138
                    n = i;
 
139
                    break;
 
140
                }
 
141
            }
 
142
            if (n < 0)
 
143
                return;
 
144
            MemberImpl results[] =
 
145
              new MemberImpl[members.length - 1];
 
146
            int j = 0;
 
147
            for (int i = 0; i < members.length; i++) {
 
148
                if (i != n)
 
149
                    results[j++] = members[i];
 
150
            }
 
151
            members = results;
 
152
        }
 
153
    }
 
154
 
 
155
    /**
 
156
     * Runs a refresh cycle and returns a list of members that has expired.
 
157
     * This also removes the members from the membership, in such a way that
 
158
     * getMembers() = getMembers() - expire()
 
159
     * @param maxtime - the max time a member can remain unannounced before it is considered dead.
 
160
     * @return the list of expired members
 
161
     */
 
162
    public synchronized MemberImpl[] expire(long maxtime) {
 
163
        if(!hasMembers() )
 
164
           return EMPTY_MEMBERS;
 
165
       
 
166
        ArrayList list = null;
 
167
        Iterator i = map.values().iterator();
 
168
        while(i.hasNext()) {
 
169
            MbrEntry entry = (MbrEntry)i.next();
 
170
            if( entry.hasExpired(maxtime) ) {
 
171
                if(list == null) // only need a list when members are expired (smaller gc)
 
172
                    list = new java.util.ArrayList();
 
173
                list.add(entry.getMember());
 
174
            }
 
175
        }
 
176
        
 
177
        if(list != null) {
 
178
            MemberImpl[] result = new MemberImpl[list.size()];
 
179
            list.toArray(result);
 
180
            for( int j=0; j<result.length; j++) {
 
181
                map.remove(result[j]);
 
182
                removeMcastMember(result[j]);
 
183
            }
 
184
            return result;
 
185
        } else {
 
186
            return EMPTY_MEMBERS ;
 
187
        }
 
188
    }
 
189
 
 
190
    /**
 
191
     * Returning that service has members or not
 
192
     */
 
193
    public synchronized boolean hasMembers() {
 
194
        return members.length > 0 ;
 
195
    }
 
196
    
 
197
    
 
198
    public synchronized MemberImpl getMember(Member mbr) {
 
199
        if(hasMembers()) {
 
200
            MemberImpl result = null;
 
201
            for ( int i=0; i<this.members.length && result==null; i++ ) {
 
202
                if ( members[i].equals(mbr) ) result = members[i];
 
203
            }//for
 
204
            return result;
 
205
        } else {
 
206
            return null;
 
207
        }
 
208
    }
 
209
 
 
210
    /**
 
211
     * Returning a list of all the members in the membership
 
212
     * We not need a copy: add and remove generate new arrays.
 
213
     */
 
214
    public synchronized MemberImpl[] getMembers() {
 
215
        if(hasMembers()) {
 
216
            return members;
 
217
        } else {
 
218
            return EMPTY_MEMBERS;
 
219
        }
 
220
    }
 
221
 
 
222
    /**
 
223
     * get a copy from all member entries
 
224
     */
 
225
    protected synchronized MbrEntry[] getMemberEntries()
 
226
    {
 
227
        MbrEntry[] result = new MbrEntry[map.size()];
 
228
        java.util.Iterator i = map.entrySet().iterator();
 
229
        int pos = 0;
 
230
        while ( i.hasNext() )
 
231
            result[pos++] = ((MbrEntry)((java.util.Map.Entry)i.next()).getValue());
 
232
        return result;
 
233
    }
 
234
    
 
235
    // --------------------------------------------- Inner Class
 
236
 
 
237
    private class MemberComparator implements java.util.Comparator {
 
238
 
 
239
        public int compare(Object o1, Object o2) {
 
240
            try {
 
241
                return compare((MemberImpl) o1, (MemberImpl) o2);
 
242
            } catch (ClassCastException x) {
 
243
                return 0;
 
244
            }
 
245
        }
 
246
 
 
247
        public int compare(MemberImpl m1, MemberImpl m2) {
 
248
            //longer alive time, means sort first
 
249
            long result = m2.getMemberAliveTime() - m1.getMemberAliveTime();
 
250
            if (result < 0)
 
251
                return -1;
 
252
            else if (result == 0)
 
253
                return 0;
 
254
            else
 
255
                return 1;
 
256
        }
 
257
    }
 
258
    
 
259
    /**
 
260
     * Inner class that represents a member entry
 
261
     */
 
262
    protected static class MbrEntry
 
263
    {
 
264
 
 
265
        protected MemberImpl mbr;
 
266
        protected long lastHeardFrom;
 
267
 
 
268
        public MbrEntry(MemberImpl mbr) {
 
269
           this.mbr = mbr;
 
270
        }
 
271
 
 
272
        /**
 
273
         * Indicate that this member has been accessed.
 
274
         */
 
275
        public void accessed(){
 
276
           lastHeardFrom = System.currentTimeMillis();
 
277
        }
 
278
 
 
279
        /**
 
280
         * Return the actual McastMember object
 
281
         */
 
282
        public MemberImpl getMember() {
 
283
            return mbr;
 
284
        }
 
285
 
 
286
        /**
 
287
         * Check if this dude has expired
 
288
         * @param maxtime The time threshold
 
289
         */
 
290
        public boolean hasExpired(long maxtime) {
 
291
            long delta = System.currentTimeMillis() - lastHeardFrom;
 
292
            return delta > maxtime;
 
293
        }
 
294
    }
 
295
}