public void run() {
Server s = null;
try {
s = Provisioning.getInstance().getLocalServer();
ZimletFile zf = new ZimletFile(upload.getName(), upload.getInputStream());
ZimletUtil.deployZimlet(zf, progress, auth, flushCache);
} catch (Exception e) {
ZimbraLog.zimlet.info("deploy", e);
if (s != null) progress.markFailed(s, e);
} finally {
FileUploadServlet.deleteUpload(upload);
}
}
private void deploy(
ZimbraSoapContext lc, String aid, ZAuthToken auth, boolean flushCache, boolean synchronous)
throws ServiceException {
Upload up = FileUploadServlet.fetchUpload(lc.getAuthtokenAccountId(), aid, lc.getAuthToken());
if (up == null) throw MailServiceException.NO_SUCH_UPLOAD(aid);
Progress pr = new Progress((auth != null));
mProgressMap.put(aid, pr);
Runnable action = new DeployThread(up, pr, auth, flushCache);
Thread t = new Thread(action);
t.start();
if (synchronous) {
try {
t.join(DEPLOY_TIMEOUT);
} catch (InterruptedException e) {
ZimbraLog.zimlet.warn("error while deploying Zimlet", e);
}
}
}
public Element handle(Element request, Map<String, Object> context) throws ServiceException {
ZimbraSoapContext zsc = getZimbraSoapContext(context);
Server localServer = Provisioning.getInstance().getLocalServer();
checkRight(zsc, context, localServer, Admin.R_createMigrationTask);
String op = request.getAttribute(AdminExtConstants.A_op);
Element response = zsc.createElement(AdminExtConstants.BULK_IMAP_DATA_IMPORT_RESPONSE);
Map<accountState, List<ExternalIMAPAccount>> IMAPAccounts = null;
String IMAPhost = null,
IMAPport = null,
adminLogin = null,
adminPassword = null,
connectionType = null,
sourceServerType = null;
String sourceType = request.getElement(AdminExtConstants.A_sourceType).getTextTrim();
String indexBatchSize = ZimbraBulkProvisionExt.DEFAULT_INDEX_BATCH_SIZE;
boolean useAdminLogin = false;
if (sourceType.equalsIgnoreCase(AdminFileDownload.FILE_FORMAT_BULK_XML)) {
String aid = request.getElement(AdminExtConstants.E_attachmentID).getTextTrim();
ZimbraLog.extensions.debug("Uploaded XML file id = " + aid);
FileUploadServlet.Upload up =
FileUploadServlet.fetchUpload(zsc.getAuthtokenAccountId(), aid, zsc.getAuthToken());
if (up == null) {
throw ServiceException.FAILURE(
"Uploaded XML file with id " + aid + " was not found.", null);
}
try {
SAXReader reader = new SAXReader();
Document doc = reader.read(up.getInputStream());
org.dom4j.Element root = doc.getRootElement();
if (!root.getName().equals(AdminExtConstants.E_ZCSImport)) {
throw new DocumentException(
"Bulk provisioning XML file's root element must be " + AdminExtConstants.E_ZCSImport);
}
Iterator rootIter = root.elementIterator(AdminExtConstants.E_ImportUsers);
if (!rootIter.hasNext()) {
throw new DocumentException(
"Cannot find element "
+ AdminExtConstants.E_ImportUsers
+ " in uploaded bulk provisioning XML file");
}
org.dom4j.Element elImportUsers = (org.dom4j.Element) rootIter.next();
IMAPAccounts = parseExternalIMAPAccounts(elImportUsers, zsc);
Iterator connectionTypeIter = root.elementIterator(AdminExtConstants.E_connectionType);
if (connectionTypeIter.hasNext()) {
org.dom4j.Element elConnectionType = (org.dom4j.Element) connectionTypeIter.next();
connectionType = elConnectionType.getTextTrim();
}
Iterator sourceServerTypeIter = root.elementIterator(AdminExtConstants.E_sourceServerType);
if (sourceServerTypeIter.hasNext()) {
org.dom4j.Element elSourceServerType = (org.dom4j.Element) sourceServerTypeIter.next();
sourceServerType = elSourceServerType.getTextTrim();
}
Iterator IMAPHostIter = root.elementIterator(AdminExtConstants.E_IMAPHost);
if (IMAPHostIter.hasNext()) {
org.dom4j.Element elIMAPHost = (org.dom4j.Element) IMAPHostIter.next();
IMAPhost = elIMAPHost.getTextTrim();
}
Iterator IMAPPortIter = root.elementIterator(AdminExtConstants.E_IMAPPort);
if (IMAPPortIter.hasNext()) {
org.dom4j.Element elIMAPPort = (org.dom4j.Element) IMAPPortIter.next();
IMAPport = elIMAPPort.getTextTrim();
}
Iterator IndexBatchSizeIter = root.elementIterator(AdminExtConstants.E_indexBatchSize);
if (IndexBatchSizeIter.hasNext()) {
org.dom4j.Element elIxBatchSize = (org.dom4j.Element) IndexBatchSizeIter.next();
indexBatchSize = elIxBatchSize.getTextTrim();
}
Iterator useAdminLoginIter = root.elementIterator(AdminExtConstants.E_useAdminLogin);
if (useAdminLoginIter.hasNext()) {
org.dom4j.Element elUseAdminLogin = (org.dom4j.Element) useAdminLoginIter.next();
useAdminLogin = "******".equalsIgnoreCase(elUseAdminLogin.getTextTrim());
if (useAdminLogin) {
Iterator adminLoginIter = root.elementIterator(AdminExtConstants.E_IMAPAdminLogin);
if (adminLoginIter.hasNext()) {
org.dom4j.Element elAdminLogin = (org.dom4j.Element) adminLoginIter.next();
adminLogin = elAdminLogin.getTextTrim();
}
Iterator adminPassIter = root.elementIterator(AdminExtConstants.E_IMAPAdminPassword);
if (adminPassIter.hasNext()) {
org.dom4j.Element elAdminPassword = (org.dom4j.Element) adminPassIter.next();
adminPassword = elAdminPassword.getTextTrim();
}
}
}
} catch (DocumentException e) {
throw ServiceException.FAILURE(
"Bulk provisioning failed to read uploaded XML document.", e);
} catch (IOException e) {
throw ServiceException.FAILURE(
"Bulk provisioning failed to read uploaded XML document.", e);
}
} else if (sourceType.equalsIgnoreCase(ZimbraBulkProvisionExt.FILE_FORMAT_ZIMBRA)) {
IMAPAccounts = getZimbraAccounts(request, zsc);
} else {
throw ServiceException.INVALID_REQUEST(
String.format(
"Invalid value of %s parameter: %s. Allowed values: %s, %s",
AdminExtConstants.A_sourceType,
sourceType,
ZimbraBulkProvisionExt.FILE_FORMAT_ZIMBRA,
AdminFileDownload.FILE_FORMAT_BULK_XML),
null);
}
/*
* Process the list of accounts. Find existing datasources and check their states.
*/
int numIdleAccounts = 0;
int numRunningAccounts = 0;
int numFinishedAccounts = 0;
List<ExternalIMAPAccount> idleAccounts = null;
if (IMAPAccounts.containsKey(accountState.idle)) {
idleAccounts = IMAPAccounts.get(accountState.idle);
if (idleAccounts != null) {
numIdleAccounts = idleAccounts.size();
}
}
List<ExternalIMAPAccount> runningAccounts;
if (IMAPAccounts.containsKey(accountState.running)) {
runningAccounts = IMAPAccounts.get(accountState.running);
if (runningAccounts != null) {
Element elRunningAccounts = response.addElement(AdminExtConstants.E_runningAccounts);
numRunningAccounts = runningAccounts.size();
Iterator<ExternalIMAPAccount> accountsIter = runningAccounts.iterator();
while (accountsIter.hasNext()) {
ExternalIMAPAccount acct = accountsIter.next();
Element elAccount = elRunningAccounts.addElement(AdminConstants.E_ACCOUNT);
elAccount.addAttribute(AdminConstants.A_NAME, acct.getAccount().getName());
elAccount.addAttribute(AdminConstants.A_ID, acct.getAccount().getId());
}
}
}
if (IMAPAccounts.containsKey(accountState.finished)) {
List accounts = IMAPAccounts.get(accountState.finished);
if (accounts != null) {
numFinishedAccounts = accounts.size();
}
}
/*
* Check for overwritten options
*/
Element elConnectionType = request.getOptionalElement(AdminExtConstants.E_connectionType);
if (elConnectionType != null) {
connectionType = elConnectionType.getTextTrim();
}
Element elSourceServerType = request.getOptionalElement(AdminExtConstants.E_sourceServerType);
if (elSourceServerType != null) {
sourceServerType = elSourceServerType.getTextTrim();
}
Element elIMAPHost = request.getOptionalElement(AdminExtConstants.E_IMAPHost);
if (elIMAPHost != null) {
IMAPhost = elIMAPHost.getTextTrim();
}
Element elIMAPPort = request.getOptionalElement(AdminExtConstants.E_IMAPPort);
if (elIMAPPort != null) {
IMAPport = elIMAPPort.getTextTrim();
}
Element elBatchSize = request.getOptionalElement(AdminExtConstants.E_indexBatchSize);
if (elBatchSize != null) {
indexBatchSize = elBatchSize.getTextTrim();
}
Element elUseAdminLogin = request.getOptionalElement(AdminExtConstants.E_useAdminLogin);
if (elUseAdminLogin != null) {
useAdminLogin = "******".equalsIgnoreCase(elUseAdminLogin.getTextTrim());
}
if (useAdminLogin) {
Element elAdminLogin = request.getOptionalElement(AdminExtConstants.E_IMAPAdminLogin);
if (elAdminLogin != null) {
adminLogin = elAdminLogin.getTextTrim();
}
Element elAdminPassword = request.getOptionalElement(AdminExtConstants.E_IMAPAdminPassword);
if (elAdminPassword != null) {
adminPassword = elAdminPassword.getTextTrim();
}
}
if (ZimbraBulkProvisionExt.OP_PREVIEW.equalsIgnoreCase(op)) {
/*
* Do not start the import. Just generate a preview. We will count
* idle and non-idle accounts.
*/
response
.addElement(AdminExtConstants.E_totalCount)
.setText(Integer.toString(numIdleAccounts + numRunningAccounts + numFinishedAccounts));
response.addElement(AdminExtConstants.E_idleCount).setText(Integer.toString(numIdleAccounts));
response
.addElement(AdminExtConstants.E_runningCount)
.setText(Integer.toString(numRunningAccounts));
response
.addElement(AdminExtConstants.E_finishedCount)
.setText(Integer.toString(numFinishedAccounts));
response.addElement(AdminExtConstants.E_connectionType).setText(connectionType);
response.addElement(AdminExtConstants.E_IMAPHost).setText(IMAPhost);
response.addElement(AdminExtConstants.E_IMAPPort).setText(IMAPport);
response.addElement(AdminExtConstants.E_indexBatchSize).setText(indexBatchSize);
if (useAdminLogin) {
response.addElement(AdminExtConstants.E_useAdminLogin).setText("1");
response.addElement(AdminExtConstants.E_IMAPAdminLogin).setText(adminLogin);
response.addElement(AdminExtConstants.E_IMAPAdminPassword).setText(adminPassword);
} else {
response.addElement(AdminExtConstants.E_useAdminLogin).setText("0");
}
} else if (ZimbraBulkProvisionExt.OP_START_IMPORT.equalsIgnoreCase(op)) {
if (idleAccounts == null) {
throw ServiceException.INVALID_REQUEST(
"None of the specified accounts are available to start import right now.", null);
}
if (IMAPhost == null) {
throw ServiceException.INVALID_REQUEST("Must specify IMAP server address!", null);
}
if (IMAPport == null) {
throw ServiceException.INVALID_REQUEST("Must specify IMAP server port number!", null);
}
if (useAdminLogin) {
/*
* We must have admin login/password if we are going to connect
* to IMAP server with admin credentials
*/
if (adminPassword == null || adminLogin == null) {
throw ServiceException.INVALID_REQUEST(
"Must specify admin credentials in order to log in as admin to IMAP server if "
+ AdminExtConstants.E_useAdminLogin
+ " option is selected!",
null);
}
}
/*
* Create the import queue
*/
Queue<HashMap<taskKeys, String>> queue =
BulkIMAPImportTaskManager.createQueue(zsc.getAuthtokenAccountId());
Queue<HashMap<taskKeys, String>> runningQ =
BulkIMAPImportTaskManager.createRunningQueue(zsc.getAuthtokenAccountId());
Iterator<ExternalIMAPAccount> idleAccIter = idleAccounts.iterator();
try {
int size = Integer.parseInt(indexBatchSize);
if (size <= 0) indexBatchSize = ZimbraBulkProvisionExt.DEFAULT_INDEX_BATCH_SIZE;
} catch (Exception e) {
indexBatchSize = ZimbraBulkProvisionExt.DEFAULT_INDEX_BATCH_SIZE;
}
while (idleAccIter.hasNext()) {
ExternalIMAPAccount acct = idleAccIter.next();
HashMap<taskKeys, String> task = new HashMap<taskKeys, String>();
String dataSourceID =
createIMAPDataSource(
acct.getAccount(),
IMAPhost,
IMAPport,
connectionType,
sourceServerType,
acct.getUserEmail(),
useAdminLogin ? adminLogin : acct.getUserLogin(),
useAdminLogin ? adminPassword : acct.getUserPassword(),
indexBatchSize,
useAdminLogin)
.getId();
String acctID = acct.getAccount().getId();
task.put(taskKeys.accountID, acctID);
task.put(taskKeys.dataSourceID, dataSourceID);
synchronized (queue) {
queue.add(task);
}
synchronized (runningQ) {
runningQ.add(task);
}
}
/*
* Start the import process
*/
BulkIMAPImportTaskManager.startImport(zsc.getAuthtokenAccountId());
} else if (ZimbraBulkProvisionExt.OP_DISMISS_IMPORT.equalsIgnoreCase(op)) {
}
return response;
}
