1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
|
/*******************************************************************************
* Copyright (c) 2009, 2010 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
* Sonatype, Inc. - ongoing development
******************************************************************************/
package org.eclipse.equinox.p2.operations;
import java.io.IOException;
import java.util.*;
import org.eclipse.core.runtime.*;
import org.eclipse.core.runtime.jobs.*;
import org.eclipse.equinox.internal.p2.core.helpers.ServiceHelper;
import org.eclipse.equinox.internal.p2.operations.Activator;
import org.eclipse.equinox.internal.p2.operations.Messages;
import org.eclipse.equinox.internal.provisional.configurator.Configurator;
import org.eclipse.equinox.internal.provisional.p2.core.eventbus.IProvisioningEventBus;
import org.eclipse.equinox.internal.provisional.p2.director.ProfileChangeRequest;
import org.eclipse.equinox.p2.core.IAgentLocation;
import org.eclipse.equinox.p2.core.IProvisioningAgent;
import org.eclipse.equinox.p2.engine.*;
import org.eclipse.equinox.p2.planner.IPlanner;
import org.eclipse.equinox.p2.query.QueryUtil;
import org.eclipse.equinox.p2.repository.artifact.IArtifactRepositoryManager;
import org.eclipse.equinox.p2.repository.metadata.IMetadataRepositoryManager;
/**
* ProvisioningSession provides the context for a provisioning session, including
* the provisioning services that should be used. It also provides utility
* methods for commonly performed provisioning tasks.
*
* @since 2.0
* @noextend This class is not intended to be subclassed by clients.
*/
public class ProvisioningSession {
private IProvisioningAgent agent;
Set<Job> scheduledJobs = Collections.synchronizedSet(new HashSet<Job>());
/**
* Create a provisioning session using the services of the supplied agent.
* @param agent the provisioning agent that supplies services. Must not be <code>null</code>.
*/
public ProvisioningSession(IProvisioningAgent agent) {
Assert.isNotNull(agent, Messages.ProvisioningSession_AgentNotFound);
this.agent = agent;
}
/**
* Return the provisioning agent used to retrieve provisioning services.
* @return the provisioning agent
*/
public IProvisioningAgent getProvisioningAgent() {
return agent;
}
/**
* Return the agent location for this session
* @return the agent location
*/
IAgentLocation getAgentLocation() {
return (IAgentLocation) agent.getService(IAgentLocation.SERVICE_NAME);
}
/**
* Return the artifact repository manager for this session
* @return the repository manager
*/
IArtifactRepositoryManager getArtifactRepositoryManager() {
return (IArtifactRepositoryManager) agent.getService(IArtifactRepositoryManager.SERVICE_NAME);
}
/**
* Return the metadata repository manager for this session
* @return the repository manager
*/
IMetadataRepositoryManager getMetadataRepositoryManager() {
return (IMetadataRepositoryManager) agent.getService(IMetadataRepositoryManager.SERVICE_NAME);
}
IProfileRegistry getProfileRegistry() {
return (IProfileRegistry) agent.getService(IProfileRegistry.SERVICE_NAME);
}
/**
* Return the provisioning engine for this session
* @return the provisioning engine
*/
IEngine getEngine() {
return (IEngine) agent.getService(IEngine.SERVICE_NAME);
}
/**
* Return the provisioning event bus used for dispatching events.
* @return the event bus
*/
IProvisioningEventBus getProvisioningEventBus() {
return (IProvisioningEventBus) agent.getService(IProvisioningEventBus.SERVICE_NAME);
}
/**
* Return the planner used for this session
* @return the planner
*/
IPlanner getPlanner() {
return (IPlanner) agent.getService(IPlanner.SERVICE_NAME);
}
/**
* Perform the specified provisioning plan.
*
* @param plan the provisioning plan to be performed
* @param phaseSet the phase set to be used for the plan
* @param context the provisioning context to be used during provisioning
* @param monitor the progress monitor to use while performing the plan
* @return a status describing the result of performing the plan
*/
public IStatus performProvisioningPlan(IProvisioningPlan plan, IPhaseSet phaseSet, ProvisioningContext context, IProgressMonitor monitor) {
IPhaseSet set;
if (phaseSet == null)
set = PhaseSetFactory.createDefaultPhaseSet();
else
set = phaseSet;
// 300 ticks for download, 100 to install handlers, 100 to compute the plan, 100 to install the rest
SubMonitor mon = SubMonitor.convert(monitor, 600);
int ticksUsed = 0;
// see https://bugs.eclipse.org/bugs/show_bug.cgi?id=272355
// The exact profile instance used in the profile change request and passed to the engine must be used for all
// of these operations, otherwise we can get profile out of synch errors.
IProfile profile = plan.getProfile();
if (plan.getInstallerPlan() != null) {
if (set instanceof PhaseSetFactory) {
// If the phase set calls for download and install, then we want to download everything atomically before
// applying the install plan. This way, we can be sure to install the install handler only if we know
// we will be able to get everything else.
ProfileChangeRequest downloadRequest = new ProfileChangeRequest(profile);
downloadRequest.setAbsoluteMode(true);
downloadRequest.addAll(QueryUtil.compoundQueryable(plan.getAdditions(), plan.getInstallerPlan().getAdditions()).query(QueryUtil.createIUAnyQuery(), null).toUnmodifiableSet());
IPhaseSet download = PhaseSetFactory.createPhaseSetIncluding(new String[] {PhaseSetFactory.PHASE_COLLECT});
IProvisioningPlan downloadPlan = getPlanner().getProvisioningPlan(downloadRequest, context, mon.newChild(100));
IStatus downloadStatus = getEngine().perform(downloadPlan, download, mon.newChild(300));
if (!downloadStatus.isOK()) {
mon.done();
return downloadStatus;
}
ticksUsed = 300;
}
// we pre-downloaded if necessary. Now perform the plan against the original phase set.
IStatus installerPlanStatus = getEngine().perform(plan.getInstallerPlan(), set, mon.newChild(100));
if (!installerPlanStatus.isOK()) {
mon.done();
return installerPlanStatus;
}
ticksUsed += 100;
// Apply the configuration
Configurator configChanger = (Configurator) ServiceHelper.getService(Activator.getContext(), Configurator.class.getName());
try {
configChanger.applyConfiguration();
} catch (IOException e) {
mon.done();
return new Status(IStatus.ERROR, Activator.ID, Messages.ProvisioningSession_InstallPlanConfigurationError, e);
}
}
return getEngine().perform(plan, set, mon.newChild(500 - ticksUsed));
}
/**
* Return a boolean indicating whether any other provisioning operations are
* scheduled for the specified profile.
*
* @param profileId the id of the profile in question
* @return <code>true</code> if there are pending provisioning operations for
* this profile, <code>false</code> if there are not.
* @see #rememberJob(Job)
*/
public boolean hasScheduledOperationsFor(String profileId) {
Job[] jobs = getScheduledJobs();
for (int i = 0; i < jobs.length; i++) {
if (jobs[i] instanceof IProfileChangeJob) {
String id = ((IProfileChangeJob) jobs[i]).getProfileId();
if (profileId.equals(id))
return true;
}
}
return false;
}
private Job[] getScheduledJobs() {
synchronized (scheduledJobs) {
return scheduledJobs.toArray(new Job[scheduledJobs.size()]);
}
}
/**
* Remember the specified job. Remembered jobs are
* checked when callers want to know what work is scheduled for
* a particular profile.
*
* @param job the job to be remembered
* @see #hasScheduledOperationsFor(String)
*/
public void rememberJob(Job job) {
scheduledJobs.add(job);
job.addJobChangeListener(new JobChangeAdapter() {
public void done(IJobChangeEvent event) {
scheduledJobs.remove(event.getJob());
}
});
}
}
|
