cleanup
[idea/community.git] / plugins / git4idea / src / git4idea / history / GitUsersComponent.java
1 /*
2  * Copyright 2000-2010 JetBrains s.r.o.
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 package git4idea.history;
17
18 import com.intellij.lifecycle.AtomicSectionsAware;
19 import com.intellij.openapi.application.PathManager;
20 import com.intellij.openapi.components.ServiceManager;
21 import com.intellij.openapi.diagnostic.Logger;
22 import com.intellij.openapi.project.Project;
23 import com.intellij.openapi.util.Pair;
24 import com.intellij.openapi.util.Ref;
25 import com.intellij.openapi.util.UpdatedReference;
26 import com.intellij.openapi.util.text.StringUtil;
27 import com.intellij.openapi.vcs.ProjectLevelVcsManager;
28 import com.intellij.openapi.vcs.VcsException;
29 import com.intellij.openapi.vcs.VcsListener;
30 import com.intellij.openapi.vcs.changes.ControlledCycle;
31 import com.intellij.openapi.vfs.VirtualFile;
32 import com.intellij.util.Consumer;
33 import com.intellij.util.io.DataExternalizer;
34 import com.intellij.util.io.EnumeratorStringDescriptor;
35 import com.intellij.util.io.PersistentHashMap;
36 import com.intellij.util.io.storage.HeavyProcessLatch;
37 import git4idea.GitVcs;
38 import git4idea.history.browser.ChangesFilter;
39 import git4idea.history.browser.GitCommit;
40 import git4idea.history.browser.LowLevelAccess;
41 import git4idea.history.browser.LowLevelAccessImpl;
42 import org.jetbrains.annotations.Nullable;
43
44 import java.io.DataInput;
45 import java.io.DataOutput;
46 import java.io.File;
47 import java.io.IOException;
48 import java.util.*;
49
50 public class GitUsersComponent {
51   private static final int ourPackSize = 50;
52   private static final int ourBackInterval = 60 * 1000;
53   private static final int ourForwardInterval = 100 * 60 * 1000;
54   
55   private static final Logger LOG = Logger.getInstance("#git4idea.history.GitUsersComponent");
56
57   private final Object myLock;
58   private PersistentHashMap<String, UsersData> myState;
59   private final Map<VirtualFile, Pair<String, LowLevelAccess>> myAccessMap;
60
61   // activate-deactivate
62   private volatile boolean myIsActive;
63   private final ControlledCycle myControlledCycle;
64   private final VcsListener myVcsListener;
65   private final GitVcs myVcs;
66   private final ProjectLevelVcsManager myManager;
67   private final File myFile;
68
69   public GitUsersComponent(final ProjectLevelVcsManager manager) {
70     myVcs = (GitVcs) manager.findVcsByName(GitVcs.getKey().getName());
71     myManager = manager;
72     myLock = new Object();
73
74     final File vcsFile = new File(PathManager.getSystemPath(), "vcs");
75     File file = new File(vcsFile, "git_users");
76     file.mkdirs();
77     myFile = new File(file, myVcs.getProject().getLocationHash());
78
79     myAccessMap = new HashMap<VirtualFile, Pair<String, LowLevelAccess>>();
80
81     // every 10 seconds is ok to check
82     myControlledCycle = new ControlledCycle(myVcs.getProject(), new MyRefresher(), "Git users loader");
83     myVcsListener = new VcsListener() {
84       public void directoryMappingChanged() {
85         final VirtualFile[] currentRoots = myManager.getRootsUnderVcs(myVcs);
86         synchronized (myLock) {
87           myAccessMap.clear();
88           for (VirtualFile currentRoot : currentRoots) {
89             myAccessMap.put(currentRoot, new Pair<String, LowLevelAccess>(currentRoot.getPath(),
90                                                                           new LowLevelAccessImpl(myVcs.getProject(), currentRoot)));
91           }
92         }
93       }
94     };
95   }
96
97   public static GitUsersComponent getInstance(final Project project) {
98     return ServiceManager.getService(project, GitUsersComponent.class);
99   }
100
101   @Nullable
102   public List<String> getUsersList(final VirtualFile root) {
103     final Pair<String, LowLevelAccess> pair = myAccessMap.get(root);
104     if (pair == null) return null;
105     try {
106       return new ArrayList<String>(myState.get(pair.getFirst()).getUsers());
107     }
108     catch (IOException e) {
109       LOG.info(e);
110       return null;
111     }
112   }
113
114   // singleton update process, only roots can change outside
115   private class MyRefresher implements ControlledCycle.MyCallback {
116     public boolean call(final AtomicSectionsAware atomicSectionsAware) {
117       atomicSectionsAware.checkShouldExit();
118       if (myIsActive) {
119         try {
120           final HashMap<VirtualFile, Pair<String, LowLevelAccess>> copy;
121           synchronized (myLock) {
122             copy = new HashMap<VirtualFile, Pair<String, LowLevelAccess>>(myAccessMap);
123           }
124
125           final Map<String, UsersData> toUpdate = new HashMap<String, UsersData>();
126           for (Pair<String, LowLevelAccess> pair : copy.values()) {
127             atomicSectionsAware.checkShouldExit();
128
129             final String key = pair.getFirst();
130             UsersData data = myState.get(key);
131             if (data == null) {
132               data = new UsersData();
133               data.forceUpdate();
134             }
135             if (data.load(pair.getSecond(), atomicSectionsAware)) {
136               toUpdate.put(key, data);
137             }
138           }
139
140           for (Map.Entry<String, UsersData> entry : toUpdate.entrySet()) {
141             myState.put(entry.getKey(), entry.getValue());
142           }
143           if (! toUpdate.isEmpty()) {
144             myState.force();
145           }
146         }
147         catch (IOException e) {
148           LOG.info(e);
149         }
150       }
151       return myIsActive;
152     }
153   }
154
155   public void activate() {
156     try {
157       myState = new PersistentHashMap<String, UsersData>(myFile, new EnumeratorStringDescriptor(), createExternalizer());
158     }
159     catch (IOException e) {
160       myState = null;
161     }
162
163     myIsActive = true;
164     myManager.addVcsListener(myVcsListener);
165     myControlledCycle.start();
166   }
167
168   public void deactivate() {
169     if (myState != null) try {
170       myState.close();
171     }
172     catch (IOException e) {
173       LOG.info(e);
174     }
175     myState = null;
176
177     synchronized (myLock) {
178       myAccessMap.clear();
179     }
180     myManager.removeVcsListener(myVcsListener);
181     myIsActive = false;
182   }
183
184   private static DataExternalizer<UsersData> createExternalizer() {
185     return new UsersDataExternalizer();
186   }
187
188   private static class UsersData {
189     private UpdatedReference<Long> myCloserDate;
190     private UpdatedReference<Long> myEarlierDate;
191     private final List<String> myUsers;
192     private boolean myForceUpdate;
193     private boolean myStartReached;
194
195     private UsersData() {
196       myUsers = new LinkedList<String>();
197       final long now = System.currentTimeMillis();
198       myCloserDate = new UpdatedReference<Long>(now);
199       myEarlierDate = new UpdatedReference<Long>(now + 1);
200     }
201
202     public UpdatedReference<Long> getCloserDate() {
203       return myCloserDate;
204     }
205
206     public void setCloserDate(UpdatedReference<Long> closerDate) {
207       myCloserDate = closerDate;
208     }
209
210     public UpdatedReference<Long> getEarlierDate() {
211       return myEarlierDate;
212     }
213
214     public void setEarlierDate(UpdatedReference<Long> earlierDate) {
215       myEarlierDate = earlierDate;
216     }
217
218     public void forceUpdate() {
219       myForceUpdate = true;
220     }
221
222     public List<String> getUsers() {
223       return myUsers;
224     }
225
226     public boolean isStartReached() {
227       return myStartReached;
228     }
229
230     public void setStartReached(boolean startReached) {
231       myStartReached = startReached;
232     }
233
234     public void addUsers(final Collection<String> users) {
235       myUsers.addAll(users);
236     }
237
238     public boolean load(final LowLevelAccess lowLevelAccess, final AtomicSectionsAware atomicSectionsAware) {
239       if (HeavyProcessLatch.INSTANCE.isRunning()) return false;
240
241       HeavyProcessLatch.INSTANCE.processStarted();
242       try {
243         final Set<String> newData = new HashSet<String>();
244         boolean result = false;
245         if (!myStartReached && (myForceUpdate || myEarlierDate.isTimeToUpdate(ourBackInterval))) {
246           result = true;
247           lookBack(lowLevelAccess, newData, atomicSectionsAware);
248         }
249         if (myForceUpdate || myCloserDate.isTimeToUpdate(ourForwardInterval)) {
250           result = true;
251           lookForward(lowLevelAccess, newData, atomicSectionsAware);
252         }
253         myForceUpdate = false;
254         
255         result |= ! newData.isEmpty();
256         putNewData(newData);
257         return result;
258       } finally {
259         HeavyProcessLatch.INSTANCE.processFinished();
260       }
261     }
262
263     private void putNewData(Set<String> newData) {
264       newData.addAll(myUsers);
265       myUsers.clear();
266       myUsers.addAll(newData);
267       Collections.sort(myUsers);
268     }
269
270     private void lookForward(LowLevelAccess lowLevelAccess, Set<String> newData, AtomicSectionsAware atomicSectionsAware) {
271       myCloserDate.updateTs();
272       loadImpl(lowLevelAccess, newData, null, new Date(myCloserDate.getT()), atomicSectionsAware);
273     }
274
275     private void lookBack(LowLevelAccess lowLevelAccess, Set<String> newData, AtomicSectionsAware atomicSectionsAware) {
276       myEarlierDate.updateTs();
277       loadImpl(lowLevelAccess, newData, new Date(myEarlierDate.getT()), null, atomicSectionsAware);
278     }
279
280     private void loadImpl(LowLevelAccess lowLevelAccess,
281                           final Set<String> newData,
282                           @Nullable final Date before,
283                           @Nullable final Date after,
284                           final AtomicSectionsAware atomicSectionsAware) {
285       try {
286         final Ref<Long> beforeTick = new Ref<Long>(Long.MAX_VALUE); // min
287         final Ref<Long> afterTick = new Ref<Long>(-1L);  // max
288         lowLevelAccess.loadCommits(Collections.<String>emptyList(), before, after, Collections.<ChangesFilter.Filter>emptyList(),
289                                    new Consumer<GitCommit>() {
290                                      public void consume(GitCommit gitCommit) {
291                                        atomicSectionsAware.checkShouldExit();
292
293                                        final long time = gitCommit.getDate().getTime();
294                                        beforeTick.set(Math.min(beforeTick.get(), time));
295                                        afterTick.set(Math.max(afterTick.get(), time));
296
297                                        if (! StringUtil.isEmptyOrSpaces(gitCommit.getAuthor())) {
298                                         newData.add(gitCommit.getAuthor());
299                                        }
300                                        if (! StringUtil.isEmptyOrSpaces(gitCommit.getCommitter())) {
301                                         newData.add(gitCommit.getCommitter());
302                                        }
303                                        if (gitCommit.getParentsHashes().isEmpty()) {
304                                          myStartReached = true;
305                                        }
306                                      }
307                                    }, ourPackSize, Collections.<String>emptyList());
308         if (myCloserDate.getT() < afterTick.get()) {
309           myCloserDate.updateT(afterTick.get());
310         }
311         if (myEarlierDate.getT() > beforeTick.get()) {
312           myEarlierDate.updateT(beforeTick.get());
313         }
314       }
315       catch (VcsException e) {
316         LOG.info(e);
317       }
318     }
319   }
320
321   private static class UsersDataExternalizer implements DataExternalizer<UsersData> {
322     public void save(DataOutput out, UsersData value) throws IOException {
323       final UpdatedReference<Long> closer = value.getCloserDate();
324       out.writeLong(closer.getT());
325       out.writeLong(closer.getTime());
326
327       final UpdatedReference<Long> earlier = value.getEarlierDate();
328       out.writeLong(earlier.getT());
329       out.writeLong(earlier.getTime());
330
331       final List<String> users = value.getUsers();
332       out.writeInt(users.size());
333       for (String user : users) {
334         out.writeUTF(user);
335       }
336
337       out.writeBoolean(value.isStartReached());
338     }
339
340     public UsersData read(DataInput in) throws IOException {
341       final UsersData data = new UsersData();
342       final long closerDate = in.readLong();
343       final long closerUpdate = in.readLong();
344       data.setCloserDate(new UpdatedReference<Long>(closerDate, closerUpdate));
345       final long earlierDate = in.readLong();
346       final long earlierUpdate = in.readLong();
347       data.setEarlierDate(new UpdatedReference<Long>(earlierDate, earlierUpdate));
348
349       final List<String> users = new LinkedList<String>();
350       final int size = in.readInt();
351       for (int i = 0; i < size; i++) {
352         users.add(in.readUTF());
353       }
354       data.addUsers(users);
355       data.setStartReached(in.readBoolean());
356       return data;
357     }
358   }
359 }