mirror of
https://github.com/vanitasvitae/Smack.git
synced 2025-12-12 14:01:08 +01:00
Prefix subprojects with 'smack-'
instead of using the old baseName=smack appendix=project.name approach, we are now going convention over configuration and renaming the subprojects directories to the proper name. Having a prefix is actually very helpful, because the resulting libraries will be named like the subproject. And a core-4.0.0-rc1.jar is not as explicit about what it actually *is* as a smack-core-4.0.0-rc1.jar. SMACK-265
This commit is contained in:
Florian Schmaus
parent
b6fb1f3743
commit
91fd15ad86
758 changed files with 42 additions and 42 deletions
|
|
@ -0,0 +1,454 @@
|
|||
/**
|
||||
*
|
||||
* Copyright 2005-2007 Jive Software.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
package org.jivesoftware.smackx.commands;
|
||||
|
||||
import org.jivesoftware.smack.SmackException.NoResponseException;
|
||||
import org.jivesoftware.smack.SmackException.NotConnectedException;
|
||||
import org.jivesoftware.smack.XMPPException.XMPPErrorException;
|
||||
import org.jivesoftware.smack.packet.XMPPError;
|
||||
import org.jivesoftware.smackx.commands.packet.AdHocCommandData;
|
||||
import org.jivesoftware.smackx.xdata.Form;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
/**
|
||||
* An ad-hoc command is responsible for executing the provided service and
|
||||
* storing the result of the execution. Each new request will create a new
|
||||
* instance of the command, allowing information related to executions to be
|
||||
* stored in it. For example suppose that a command that retrieves the list of
|
||||
* users on a server is implemented. When the command is executed it gets that
|
||||
* list and the result is stored as a form in the command instance, i.e. the
|
||||
* <code>getForm</code> method retrieves a form with all the users.
|
||||
* <p>
|
||||
* Each command has a <tt>node</tt> that should be unique within a given JID.
|
||||
* <p>
|
||||
* Commands may have zero or more stages. Each stage is usually used for
|
||||
* gathering information required for the command execution. Users are able to
|
||||
* move forward or backward across the different stages. Commands may not be
|
||||
* cancelled while they are being executed. However, users may request the
|
||||
* "cancel" action when submitting a stage response indicating that the command
|
||||
* execution should be aborted. Thus, releasing any collected information.
|
||||
* Commands that require user interaction (i.e. have more than one stage) will
|
||||
* have to provide the data forms the user must complete in each stage and the
|
||||
* allowed actions the user might perform during each stage (e.g. go to the
|
||||
* previous stage or go to the next stage).
|
||||
* <p>
|
||||
* All the actions may throw an XMPPException if there is a problem executing
|
||||
* them. The <code>XMPPError</code> of that exception may have some specific
|
||||
* information about the problem. The possible extensions are:
|
||||
*
|
||||
* <li><i>malformed-action</i>. Extension of a <i>bad-request</i> error.</li>
|
||||
* <li><i>bad-action</i>. Extension of a <i>bad-request</i> error.</li>
|
||||
* <li><i>bad-locale</i>. Extension of a <i>bad-request</i> error.</li>
|
||||
* <li><i>bad-payload</i>. Extension of a <i>bad-request</i> error.</li>
|
||||
* <li><i>bad-sessionid</i>. Extension of a <i>bad-request</i> error.</li>
|
||||
* <li><i>session-expired</i>. Extension of a <i>not-allowed</i> error.</li>
|
||||
* <p>
|
||||
* See the <code>SpecificErrorCondition</code> class for detailed description
|
||||
* of each one.
|
||||
* <p>
|
||||
* Use the <code>getSpecificErrorConditionFrom</code> to obtain the specific
|
||||
* information from an <code>XMPPError</code>.
|
||||
*
|
||||
* @author Gabriel Guardincerri
|
||||
*
|
||||
*/
|
||||
public abstract class AdHocCommand {
|
||||
// TODO: Analyze the redesign of command by having an ExecutionResponse as a
|
||||
// TODO: result to the execution of every action. That result should have all the
|
||||
// TODO: information related to the execution, e.g. the form to fill. Maybe this
|
||||
// TODO: design is more intuitive and simpler than the current one that has all in
|
||||
// TODO: one class.
|
||||
|
||||
private AdHocCommandData data;
|
||||
|
||||
public AdHocCommand() {
|
||||
super();
|
||||
data = new AdHocCommandData();
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the specific condition of the <code>error</code> or <tt>null</tt> if the
|
||||
* error doesn't have any.
|
||||
*
|
||||
* @param error the error the get the specific condition from.
|
||||
* @return the specific condition of this error, or null if it doesn't have
|
||||
* any.
|
||||
*/
|
||||
public static SpecificErrorCondition getSpecificErrorCondition(XMPPError error) {
|
||||
// This method is implemented to provide an easy way of getting a packet
|
||||
// extension of the XMPPError.
|
||||
for (SpecificErrorCondition condition : SpecificErrorCondition.values()) {
|
||||
if (error.getExtension(condition.toString(),
|
||||
AdHocCommandData.SpecificError.namespace) != null) {
|
||||
return condition;
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set the the human readable name of the command, usually used for
|
||||
* displaying in a UI.
|
||||
*
|
||||
* @param name the name.
|
||||
*/
|
||||
public void setName(String name) {
|
||||
data.setName(name);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the human readable name of the command.
|
||||
*
|
||||
* @return the human readable name of the command
|
||||
*/
|
||||
public String getName() {
|
||||
return data.getName();
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the unique identifier of the command. This value must be unique for
|
||||
* the <code>OwnerJID</code>.
|
||||
*
|
||||
* @param node the unique identifier of the command.
|
||||
*/
|
||||
public void setNode(String node) {
|
||||
data.setNode(node);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the unique identifier of the command. It is unique for the
|
||||
* <code>OwnerJID</code>.
|
||||
*
|
||||
* @return the unique identifier of the command.
|
||||
*/
|
||||
public String getNode() {
|
||||
return data.getNode();
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the full JID of the owner of this command. This JID is the "to" of a
|
||||
* execution request.
|
||||
*
|
||||
* @return the owner JID.
|
||||
*/
|
||||
public abstract String getOwnerJID();
|
||||
|
||||
/**
|
||||
* Returns the notes that the command has at the current stage.
|
||||
*
|
||||
* @return a list of notes.
|
||||
*/
|
||||
public List<AdHocCommandNote> getNotes() {
|
||||
return data.getNotes();
|
||||
}
|
||||
|
||||
/**
|
||||
* Adds a note to the current stage. This should be used when setting a
|
||||
* response to the execution of an action. All the notes added here are
|
||||
* returned by the {@link #getNotes} method during the current stage.
|
||||
* Once the stage changes all the notes are discarded.
|
||||
*
|
||||
* @param note the note.
|
||||
*/
|
||||
protected void addNote(AdHocCommandNote note) {
|
||||
data.addNote(note);
|
||||
}
|
||||
|
||||
public String getRaw() {
|
||||
return data.getChildElementXML();
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the form of the current stage. Usually it is the form that must
|
||||
* be answered to execute the next action. If that is the case it should be
|
||||
* used by the requester to fill all the information that the executor needs
|
||||
* to continue to the next stage. It can also be the result of the
|
||||
* execution.
|
||||
*
|
||||
* @return the form of the current stage to fill out or the result of the
|
||||
* execution.
|
||||
*/
|
||||
public Form getForm() {
|
||||
if (data.getForm() == null) {
|
||||
return null;
|
||||
}
|
||||
else {
|
||||
return new Form(data.getForm());
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the form of the current stage. This should be used when setting a
|
||||
* response. It could be a form to fill out the information needed to go to
|
||||
* the next stage or the result of an execution.
|
||||
*
|
||||
* @param form the form of the current stage to fill out or the result of the
|
||||
* execution.
|
||||
*/
|
||||
protected void setForm(Form form) {
|
||||
data.setForm(form.getDataFormToSend());
|
||||
}
|
||||
|
||||
/**
|
||||
* Executes the command. This is invoked only on the first stage of the
|
||||
* command. It is invoked on every command. If there is a problem executing
|
||||
* the command it throws an XMPPException.
|
||||
*
|
||||
* @throws XMPPErrorException if there is an error executing the command.
|
||||
* @throws NotConnectedException
|
||||
*/
|
||||
public abstract void execute() throws NoResponseException, XMPPErrorException, NotConnectedException;
|
||||
|
||||
/**
|
||||
* Executes the next action of the command with the information provided in
|
||||
* the <code>response</code>. This form must be the answer form of the
|
||||
* previous stage. This method will be only invoked for commands that have one
|
||||
* or more stages. If there is a problem executing the command it throws an
|
||||
* XMPPException.
|
||||
*
|
||||
* @param response the form answer of the previous stage.
|
||||
* @throws XMPPErrorException if there is a problem executing the command.
|
||||
* @throws NotConnectedException
|
||||
*/
|
||||
public abstract void next(Form response) throws NoResponseException, XMPPErrorException, NotConnectedException;
|
||||
|
||||
/**
|
||||
* Completes the command execution with the information provided in the
|
||||
* <code>response</code>. This form must be the answer form of the
|
||||
* previous stage. This method will be only invoked for commands that have one
|
||||
* or more stages. If there is a problem executing the command it throws an
|
||||
* XMPPException.
|
||||
*
|
||||
* @param response the form answer of the previous stage.
|
||||
* @throws XMPPErrorException if there is a problem executing the command.
|
||||
* @throws NotConnectedException
|
||||
*/
|
||||
public abstract void complete(Form response) throws NoResponseException, XMPPErrorException, NotConnectedException;
|
||||
|
||||
/**
|
||||
* Goes to the previous stage. The requester is asking to re-send the
|
||||
* information of the previous stage. The command must change it state to
|
||||
* the previous one. If there is a problem executing the command it throws
|
||||
* an XMPPException.
|
||||
*
|
||||
* @throws XMPPErrorException if there is a problem executing the command.
|
||||
* @throws NotConnectedException
|
||||
*/
|
||||
public abstract void prev() throws NoResponseException, XMPPErrorException, NotConnectedException;
|
||||
|
||||
/**
|
||||
* Cancels the execution of the command. This can be invoked on any stage of
|
||||
* the execution. If there is a problem executing the command it throws an
|
||||
* XMPPException.
|
||||
*
|
||||
* @throws XMPPErrorException if there is a problem executing the command.
|
||||
* @throws NotConnectedException
|
||||
*/
|
||||
public abstract void cancel() throws NoResponseException, XMPPErrorException, NotConnectedException;
|
||||
|
||||
/**
|
||||
* Returns a collection with the allowed actions based on the current stage.
|
||||
* Possible actions are: {@link Action#prev prev}, {@link Action#next next} and
|
||||
* {@link Action#complete complete}. This method will be only invoked for commands that
|
||||
* have one or more stages.
|
||||
*
|
||||
* @return a collection with the allowed actions based on the current stage
|
||||
* as defined in the SessionData.
|
||||
*/
|
||||
protected List<Action> getActions() {
|
||||
return data.getActions();
|
||||
}
|
||||
|
||||
/**
|
||||
* Add an action to the current stage available actions. This should be used
|
||||
* when creating a response.
|
||||
*
|
||||
* @param action the action.
|
||||
*/
|
||||
protected void addActionAvailable(Action action) {
|
||||
data.addAction(action);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the action available for the current stage which is
|
||||
* considered the equivalent to "execute". When the requester sends his
|
||||
* reply, if no action was defined in the command then the action will be
|
||||
* assumed "execute" thus assuming the action returned by this method. This
|
||||
* method will never be invoked for commands that have no stages.
|
||||
*
|
||||
* @return the action available for the current stage which is considered
|
||||
* the equivalent to "execute".
|
||||
*/
|
||||
protected Action getExecuteAction() {
|
||||
return data.getExecuteAction();
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets which of the actions available for the current stage is
|
||||
* considered the equivalent to "execute". This should be used when setting
|
||||
* a response. When the requester sends his reply, if no action was defined
|
||||
* in the command then the action will be assumed "execute" thus assuming
|
||||
* the action returned by this method.
|
||||
*
|
||||
* @param action the action.
|
||||
*/
|
||||
protected void setExecuteAction(Action action) {
|
||||
data.setExecuteAction(action);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the status of the current stage.
|
||||
*
|
||||
* @return the current status.
|
||||
*/
|
||||
public Status getStatus() {
|
||||
return data.getStatus();
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the data of the current stage. This should not used.
|
||||
*
|
||||
* @param data the data.
|
||||
*/
|
||||
void setData(AdHocCommandData data) {
|
||||
this.data = data;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the data of the current stage. This should not used.
|
||||
*
|
||||
* @return the data.
|
||||
*/
|
||||
AdHocCommandData getData() {
|
||||
return data;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns true if the <code>action</code> is available in the current stage.
|
||||
* The {@link Action#cancel cancel} action is always allowed. To define the
|
||||
* available actions use the <code>addActionAvailable</code> method.
|
||||
*
|
||||
* @param action
|
||||
* The action to check if it is available.
|
||||
* @return True if the action is available for the current stage.
|
||||
*/
|
||||
protected boolean isValidAction(Action action) {
|
||||
return getActions().contains(action) || Action.cancel.equals(action);
|
||||
}
|
||||
|
||||
/**
|
||||
* The status of the stage in the adhoc command.
|
||||
*/
|
||||
public enum Status {
|
||||
|
||||
/**
|
||||
* The command is being executed.
|
||||
*/
|
||||
executing,
|
||||
|
||||
/**
|
||||
* The command has completed. The command session has ended.
|
||||
*/
|
||||
completed,
|
||||
|
||||
/**
|
||||
* The command has been canceled. The command session has ended.
|
||||
*/
|
||||
canceled
|
||||
}
|
||||
|
||||
public enum Action {
|
||||
|
||||
/**
|
||||
* The command should be executed or continue to be executed. This is
|
||||
* the default value.
|
||||
*/
|
||||
execute,
|
||||
|
||||
/**
|
||||
* The command should be canceled.
|
||||
*/
|
||||
cancel,
|
||||
|
||||
/**
|
||||
* The command should be digress to the previous stage of execution.
|
||||
*/
|
||||
prev,
|
||||
|
||||
/**
|
||||
* The command should progress to the next stage of execution.
|
||||
*/
|
||||
next,
|
||||
|
||||
/**
|
||||
* The command should be completed (if possible).
|
||||
*/
|
||||
complete,
|
||||
|
||||
/**
|
||||
* The action is unknow. This is used when a recieved message has an
|
||||
* unknown action. It must not be used to send an execution request.
|
||||
*/
|
||||
unknown
|
||||
}
|
||||
|
||||
public enum SpecificErrorCondition {
|
||||
|
||||
/**
|
||||
* The responding JID cannot accept the specified action.
|
||||
*/
|
||||
badAction("bad-action"),
|
||||
|
||||
/**
|
||||
* The responding JID does not understand the specified action.
|
||||
*/
|
||||
malformedAction("malformed-action"),
|
||||
|
||||
/**
|
||||
* The responding JID cannot accept the specified language/locale.
|
||||
*/
|
||||
badLocale("bad-locale"),
|
||||
|
||||
/**
|
||||
* The responding JID cannot accept the specified payload (e.g. the data
|
||||
* form did not provide one or more required fields).
|
||||
*/
|
||||
badPayload("bad-payload"),
|
||||
|
||||
/**
|
||||
* The responding JID cannot accept the specified sessionid.
|
||||
*/
|
||||
badSessionid("bad-sessionid"),
|
||||
|
||||
/**
|
||||
* The requesting JID specified a sessionid that is no longer active
|
||||
* (either because it was completed, canceled, or timed out).
|
||||
*/
|
||||
sessionExpired("session-expired");
|
||||
|
||||
private String value;
|
||||
|
||||
SpecificErrorCondition(String value) {
|
||||
this.value = value;
|
||||
}
|
||||
|
||||
public String toString() {
|
||||
return value;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,707 @@
|
|||
/**
|
||||
*
|
||||
* Copyright 2005-2008 Jive Software.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
package org.jivesoftware.smackx.commands;
|
||||
|
||||
import org.jivesoftware.smack.*;
|
||||
import org.jivesoftware.smack.SmackException.NotConnectedException;
|
||||
import org.jivesoftware.smack.XMPPException.XMPPErrorException;
|
||||
import org.jivesoftware.smack.filter.PacketFilter;
|
||||
import org.jivesoftware.smack.filter.PacketTypeFilter;
|
||||
import org.jivesoftware.smack.packet.IQ;
|
||||
import org.jivesoftware.smack.packet.Packet;
|
||||
import org.jivesoftware.smack.packet.PacketExtension;
|
||||
import org.jivesoftware.smack.packet.XMPPError;
|
||||
import org.jivesoftware.smack.util.StringUtils;
|
||||
import org.jivesoftware.smackx.commands.AdHocCommand.Action;
|
||||
import org.jivesoftware.smackx.commands.AdHocCommand.Status;
|
||||
import org.jivesoftware.smackx.commands.packet.AdHocCommandData;
|
||||
import org.jivesoftware.smackx.disco.NodeInformationProvider;
|
||||
import org.jivesoftware.smackx.disco.ServiceDiscoveryManager;
|
||||
import org.jivesoftware.smackx.disco.packet.DiscoverInfo;
|
||||
import org.jivesoftware.smackx.disco.packet.DiscoverItems;
|
||||
import org.jivesoftware.smackx.disco.packet.DiscoverInfo.Identity;
|
||||
import org.jivesoftware.smackx.xdata.Form;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Collection;
|
||||
import java.util.Collections;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.WeakHashMap;
|
||||
import java.util.concurrent.ConcurrentHashMap;
|
||||
|
||||
/**
|
||||
* An AdHocCommandManager is responsible for keeping the list of available
|
||||
* commands offered by a service and for processing commands requests.
|
||||
*
|
||||
* Pass in a XMPPConnection instance to
|
||||
* {@link #getAddHocCommandsManager(org.jivesoftware.smack.XMPPConnection)} in order to
|
||||
* get an instance of this class.
|
||||
*
|
||||
* @author Gabriel Guardincerri
|
||||
*/
|
||||
public class AdHocCommandManager extends Manager {
|
||||
public static final String NAMESPACE = "http://jabber.org/protocol/commands";
|
||||
|
||||
/**
|
||||
* The session time out in seconds.
|
||||
*/
|
||||
private static final int SESSION_TIMEOUT = 2 * 60;
|
||||
|
||||
/**
|
||||
* Map a XMPPConnection with it AdHocCommandManager. This map have a key-value
|
||||
* pair for every active connection.
|
||||
*/
|
||||
private static Map<XMPPConnection, AdHocCommandManager> instances =
|
||||
Collections.synchronizedMap(new WeakHashMap<XMPPConnection, AdHocCommandManager>());
|
||||
|
||||
/**
|
||||
* Register the listener for all the connection creations. When a new
|
||||
* connection is created a new AdHocCommandManager is also created and
|
||||
* related to that connection.
|
||||
*/
|
||||
static {
|
||||
XMPPConnection.addConnectionCreationListener(new ConnectionCreationListener() {
|
||||
public void connectionCreated(XMPPConnection connection) {
|
||||
getAddHocCommandsManager(connection);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the <code>AdHocCommandManager</code> related to the
|
||||
* <code>connection</code>.
|
||||
*
|
||||
* @param connection the XMPP connection.
|
||||
* @return the AdHocCommandManager associated with the connection.
|
||||
*/
|
||||
public static synchronized AdHocCommandManager getAddHocCommandsManager(XMPPConnection connection) {
|
||||
AdHocCommandManager ahcm = instances.get(connection);
|
||||
if (ahcm == null) ahcm = new AdHocCommandManager(connection);
|
||||
return ahcm;
|
||||
}
|
||||
|
||||
/**
|
||||
* Map a command node with its AdHocCommandInfo. Note: Key=command node,
|
||||
* Value=command. Command node matches the node attribute sent by command
|
||||
* requesters.
|
||||
*/
|
||||
private final Map<String, AdHocCommandInfo> commands = new ConcurrentHashMap<String, AdHocCommandInfo>();
|
||||
|
||||
/**
|
||||
* Map a command session ID with the instance LocalCommand. The LocalCommand
|
||||
* is the an objects that has all the information of the current state of
|
||||
* the command execution. Note: Key=session ID, Value=LocalCommand. Session
|
||||
* ID matches the sessionid attribute sent by command responders.
|
||||
*/
|
||||
private final Map<String, LocalCommand> executingCommands = new ConcurrentHashMap<String, LocalCommand>();
|
||||
|
||||
private final ServiceDiscoveryManager serviceDiscoveryManager;
|
||||
|
||||
/**
|
||||
* Thread that reaps stale sessions.
|
||||
*/
|
||||
private Thread sessionsSweeper;
|
||||
|
||||
private AdHocCommandManager(XMPPConnection connection) {
|
||||
super(connection);
|
||||
this.serviceDiscoveryManager = ServiceDiscoveryManager.getInstanceFor(connection);
|
||||
|
||||
// Register the new instance and associate it with the connection
|
||||
instances.put(connection, this);
|
||||
|
||||
// Add the feature to the service discovery manage to show that this
|
||||
// connection supports the AdHoc-Commands protocol.
|
||||
// This information will be used when another client tries to
|
||||
// discover whether this client supports AdHoc-Commands or not.
|
||||
ServiceDiscoveryManager.getInstanceFor(connection).addFeature(
|
||||
NAMESPACE);
|
||||
|
||||
// Set the NodeInformationProvider that will provide information about
|
||||
// which AdHoc-Commands are registered, whenever a disco request is
|
||||
// received
|
||||
ServiceDiscoveryManager.getInstanceFor(connection)
|
||||
.setNodeInformationProvider(NAMESPACE,
|
||||
new NodeInformationProvider() {
|
||||
public List<DiscoverItems.Item> getNodeItems() {
|
||||
|
||||
List<DiscoverItems.Item> answer = new ArrayList<DiscoverItems.Item>();
|
||||
Collection<AdHocCommandInfo> commandsList = getRegisteredCommands();
|
||||
|
||||
for (AdHocCommandInfo info : commandsList) {
|
||||
DiscoverItems.Item item = new DiscoverItems.Item(
|
||||
info.getOwnerJID());
|
||||
item.setName(info.getName());
|
||||
item.setNode(info.getNode());
|
||||
answer.add(item);
|
||||
}
|
||||
|
||||
return answer;
|
||||
}
|
||||
|
||||
public List<String> getNodeFeatures() {
|
||||
return null;
|
||||
}
|
||||
|
||||
public List<Identity> getNodeIdentities() {
|
||||
return null;
|
||||
}
|
||||
|
||||
@Override
|
||||
public List<PacketExtension> getNodePacketExtensions() {
|
||||
return null;
|
||||
}
|
||||
});
|
||||
|
||||
// The packet listener and the filter for processing some AdHoc Commands
|
||||
// Packets
|
||||
PacketListener listener = new PacketListener() {
|
||||
public void processPacket(Packet packet) {
|
||||
AdHocCommandData requestData = (AdHocCommandData) packet;
|
||||
try {
|
||||
processAdHocCommand(requestData);
|
||||
}
|
||||
catch (SmackException e) {
|
||||
return;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
PacketFilter filter = new PacketTypeFilter(AdHocCommandData.class);
|
||||
connection.addPacketListener(listener, filter);
|
||||
|
||||
sessionsSweeper = null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Registers a new command with this command manager, which is related to a
|
||||
* connection. The <tt>node</tt> is an unique identifier of that command for
|
||||
* the connection related to this command manager. The <tt>name</tt> is the
|
||||
* human readable name of the command. The <tt>class</tt> is the class of
|
||||
* the command, which must extend {@link LocalCommand} and have a default
|
||||
* constructor.
|
||||
*
|
||||
* @param node the unique identifier of the command.
|
||||
* @param name the human readable name of the command.
|
||||
* @param clazz the class of the command, which must extend {@link LocalCommand}.
|
||||
*/
|
||||
public void registerCommand(String node, String name, final Class<? extends LocalCommand> clazz) {
|
||||
registerCommand(node, name, new LocalCommandFactory() {
|
||||
public LocalCommand getInstance() throws InstantiationException, IllegalAccessException {
|
||||
return clazz.newInstance();
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Registers a new command with this command manager, which is related to a
|
||||
* connection. The <tt>node</tt> is an unique identifier of that
|
||||
* command for the connection related to this command manager. The <tt>name</tt>
|
||||
* is the human readeale name of the command. The <tt>factory</tt> generates
|
||||
* new instances of the command.
|
||||
*
|
||||
* @param node the unique identifier of the command.
|
||||
* @param name the human readable name of the command.
|
||||
* @param factory a factory to create new instances of the command.
|
||||
*/
|
||||
public void registerCommand(String node, final String name, LocalCommandFactory factory) {
|
||||
AdHocCommandInfo commandInfo = new AdHocCommandInfo(node, name, connection().getUser(), factory);
|
||||
|
||||
commands.put(node, commandInfo);
|
||||
// Set the NodeInformationProvider that will provide information about
|
||||
// the added command
|
||||
serviceDiscoveryManager.setNodeInformationProvider(node,
|
||||
new NodeInformationProvider() {
|
||||
public List<DiscoverItems.Item> getNodeItems() {
|
||||
return null;
|
||||
}
|
||||
|
||||
public List<String> getNodeFeatures() {
|
||||
List<String> answer = new ArrayList<String>();
|
||||
answer.add(NAMESPACE);
|
||||
// TODO: check if this service is provided by the
|
||||
// TODO: current connection.
|
||||
answer.add("jabber:x:data");
|
||||
return answer;
|
||||
}
|
||||
|
||||
public List<DiscoverInfo.Identity> getNodeIdentities() {
|
||||
List<DiscoverInfo.Identity> answer = new ArrayList<DiscoverInfo.Identity>();
|
||||
DiscoverInfo.Identity identity = new DiscoverInfo.Identity(
|
||||
"automation", name, "command-node");
|
||||
answer.add(identity);
|
||||
return answer;
|
||||
}
|
||||
|
||||
@Override
|
||||
public List<PacketExtension> getNodePacketExtensions() {
|
||||
return null;
|
||||
}
|
||||
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Discover the commands of an specific JID. The <code>jid</code> is a
|
||||
* full JID.
|
||||
*
|
||||
* @param jid the full JID to retrieve the commands for.
|
||||
* @return the discovered items.
|
||||
* @throws XMPPException if the operation failed for some reason.
|
||||
* @throws SmackException if there was no response from the server.
|
||||
*/
|
||||
public DiscoverItems discoverCommands(String jid) throws XMPPException, SmackException {
|
||||
return serviceDiscoveryManager.discoverItems(jid, NAMESPACE);
|
||||
}
|
||||
|
||||
/**
|
||||
* Publish the commands to an specific JID.
|
||||
*
|
||||
* @param jid the full JID to publish the commands to.
|
||||
* @throws XMPPException if the operation failed for some reason.
|
||||
* @throws SmackException if there was no response from the server.
|
||||
*/
|
||||
public void publishCommands(String jid) throws XMPPException, SmackException {
|
||||
// Collects the commands to publish as items
|
||||
DiscoverItems discoverItems = new DiscoverItems();
|
||||
Collection<AdHocCommandInfo> xCommandsList = getRegisteredCommands();
|
||||
|
||||
for (AdHocCommandInfo info : xCommandsList) {
|
||||
DiscoverItems.Item item = new DiscoverItems.Item(info.getOwnerJID());
|
||||
item.setName(info.getName());
|
||||
item.setNode(info.getNode());
|
||||
discoverItems.addItem(item);
|
||||
}
|
||||
|
||||
serviceDiscoveryManager.publishItems(jid, NAMESPACE, discoverItems);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns a command that represents an instance of a command in a remote
|
||||
* host. It is used to execute remote commands. The concept is similar to
|
||||
* RMI. Every invocation on this command is equivalent to an invocation in
|
||||
* the remote command.
|
||||
*
|
||||
* @param jid the full JID of the host of the remote command
|
||||
* @param node the identifier of the command
|
||||
* @return a local instance equivalent to the remote command.
|
||||
*/
|
||||
public RemoteCommand getRemoteCommand(String jid, String node) {
|
||||
return new RemoteCommand(connection(), node, jid);
|
||||
}
|
||||
|
||||
/**
|
||||
* Process the AdHoc-Command packet that request the execution of some
|
||||
* action of a command. If this is the first request, this method checks,
|
||||
* before executing the command, if:
|
||||
* <ul>
|
||||
* <li>The requested command exists</li>
|
||||
* <li>The requester has permissions to execute it</li>
|
||||
* <li>The command has more than one stage, if so, it saves the command and
|
||||
* session ID for further use</li>
|
||||
* </ul>
|
||||
*
|
||||
* <br>
|
||||
* <br>
|
||||
* If this is not the first request, this method checks, before executing
|
||||
* the command, if:
|
||||
* <ul>
|
||||
* <li>The session ID of the request was stored</li>
|
||||
* <li>The session life do not exceed the time out</li>
|
||||
* <li>The action to execute is one of the available actions</li>
|
||||
* </ul>
|
||||
*
|
||||
* @param requestData
|
||||
* the packet to process.
|
||||
* @throws SmackException if there was no response from the server.
|
||||
*/
|
||||
private void processAdHocCommand(AdHocCommandData requestData) throws SmackException {
|
||||
// Only process requests of type SET
|
||||
if (requestData.getType() != IQ.Type.SET) {
|
||||
return;
|
||||
}
|
||||
|
||||
// Creates the response with the corresponding data
|
||||
AdHocCommandData response = new AdHocCommandData();
|
||||
response.setTo(requestData.getFrom());
|
||||
response.setPacketID(requestData.getPacketID());
|
||||
response.setNode(requestData.getNode());
|
||||
response.setId(requestData.getTo());
|
||||
|
||||
String sessionId = requestData.getSessionID();
|
||||
String commandNode = requestData.getNode();
|
||||
|
||||
if (sessionId == null) {
|
||||
// A new execution request has been received. Check that the
|
||||
// command exists
|
||||
if (!commands.containsKey(commandNode)) {
|
||||
// Requested command does not exist so return
|
||||
// item_not_found error.
|
||||
respondError(response, XMPPError.Condition.item_not_found);
|
||||
return;
|
||||
}
|
||||
|
||||
// Create new session ID
|
||||
sessionId = StringUtils.randomString(15);
|
||||
|
||||
try {
|
||||
// Create a new instance of the command with the
|
||||
// corresponding sessioid
|
||||
LocalCommand command = newInstanceOfCmd(commandNode, sessionId);
|
||||
|
||||
response.setType(IQ.Type.RESULT);
|
||||
command.setData(response);
|
||||
|
||||
// Check that the requester has enough permission.
|
||||
// Answer forbidden error if requester permissions are not
|
||||
// enough to execute the requested command
|
||||
if (!command.hasPermission(requestData.getFrom())) {
|
||||
respondError(response, XMPPError.Condition.forbidden);
|
||||
return;
|
||||
}
|
||||
|
||||
Action action = requestData.getAction();
|
||||
|
||||
// If the action is unknown then respond an error.
|
||||
if (action != null && action.equals(Action.unknown)) {
|
||||
respondError(response, XMPPError.Condition.bad_request,
|
||||
AdHocCommand.SpecificErrorCondition.malformedAction);
|
||||
return;
|
||||
}
|
||||
|
||||
// If the action is not execute, then it is an invalid action.
|
||||
if (action != null && !action.equals(Action.execute)) {
|
||||
respondError(response, XMPPError.Condition.bad_request,
|
||||
AdHocCommand.SpecificErrorCondition.badAction);
|
||||
return;
|
||||
}
|
||||
|
||||
// Increase the state number, so the command knows in witch
|
||||
// stage it is
|
||||
command.incrementStage();
|
||||
// Executes the command
|
||||
command.execute();
|
||||
|
||||
if (command.isLastStage()) {
|
||||
// If there is only one stage then the command is completed
|
||||
response.setStatus(Status.completed);
|
||||
}
|
||||
else {
|
||||
// Else it is still executing, and is registered to be
|
||||
// available for the next call
|
||||
response.setStatus(Status.executing);
|
||||
executingCommands.put(sessionId, command);
|
||||
// See if the session reaping thread is started. If not, start it.
|
||||
if (sessionsSweeper == null) {
|
||||
sessionsSweeper = new Thread(new Runnable() {
|
||||
public void run() {
|
||||
while (true) {
|
||||
for (String sessionId : executingCommands.keySet()) {
|
||||
LocalCommand command = executingCommands.get(sessionId);
|
||||
// Since the command could be removed in the meanwhile
|
||||
// of getting the key and getting the value - by a
|
||||
// processed packet. We must check if it still in the
|
||||
// map.
|
||||
if (command != null) {
|
||||
long creationStamp = command.getCreationDate();
|
||||
// Check if the Session data has expired (default is
|
||||
// 10 minutes)
|
||||
// To remove it from the session list it waits for
|
||||
// the double of the of time out time. This is to
|
||||
// let
|
||||
// the requester know why his execution request is
|
||||
// not accepted. If the session is removed just
|
||||
// after the time out, then whe the user request to
|
||||
// continue the execution he will recieved an
|
||||
// invalid session error and not a time out error.
|
||||
if (System.currentTimeMillis() - creationStamp > SESSION_TIMEOUT * 1000 * 2) {
|
||||
// Remove the expired session
|
||||
executingCommands.remove(sessionId);
|
||||
}
|
||||
}
|
||||
}
|
||||
try {
|
||||
Thread.sleep(1000);
|
||||
}
|
||||
catch (InterruptedException ie) {
|
||||
// Ignore.
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
});
|
||||
sessionsSweeper.setDaemon(true);
|
||||
sessionsSweeper.start();
|
||||
}
|
||||
}
|
||||
|
||||
// Sends the response packet
|
||||
connection().sendPacket(response);
|
||||
|
||||
}
|
||||
catch (XMPPErrorException e) {
|
||||
// If there is an exception caused by the next, complete,
|
||||
// prev or cancel method, then that error is returned to the
|
||||
// requester.
|
||||
XMPPError error = e.getXMPPError();
|
||||
|
||||
// If the error type is cancel, then the execution is
|
||||
// canceled therefore the status must show that, and the
|
||||
// command be removed from the executing list.
|
||||
if (XMPPError.Type.CANCEL.equals(error.getType())) {
|
||||
response.setStatus(Status.canceled);
|
||||
executingCommands.remove(sessionId);
|
||||
}
|
||||
respondError(response, error);
|
||||
}
|
||||
}
|
||||
else {
|
||||
LocalCommand command = executingCommands.get(sessionId);
|
||||
|
||||
// Check that a command exists for the specified sessionID
|
||||
// This also handles if the command was removed in the meanwhile
|
||||
// of getting the key and the value of the map.
|
||||
if (command == null) {
|
||||
respondError(response, XMPPError.Condition.bad_request,
|
||||
AdHocCommand.SpecificErrorCondition.badSessionid);
|
||||
return;
|
||||
}
|
||||
|
||||
// Check if the Session data has expired (default is 10 minutes)
|
||||
long creationStamp = command.getCreationDate();
|
||||
if (System.currentTimeMillis() - creationStamp > SESSION_TIMEOUT * 1000) {
|
||||
// Remove the expired session
|
||||
executingCommands.remove(sessionId);
|
||||
|
||||
// Answer a not_allowed error (session-expired)
|
||||
respondError(response, XMPPError.Condition.not_allowed,
|
||||
AdHocCommand.SpecificErrorCondition.sessionExpired);
|
||||
return;
|
||||
}
|
||||
|
||||
/*
|
||||
* Since the requester could send two requests for the same
|
||||
* executing command i.e. the same session id, all the execution of
|
||||
* the action must be synchronized to avoid inconsistencies.
|
||||
*/
|
||||
synchronized (command) {
|
||||
Action action = requestData.getAction();
|
||||
|
||||
// If the action is unknown the respond an error
|
||||
if (action != null && action.equals(Action.unknown)) {
|
||||
respondError(response, XMPPError.Condition.bad_request,
|
||||
AdHocCommand.SpecificErrorCondition.malformedAction);
|
||||
return;
|
||||
}
|
||||
|
||||
// If the user didn't specify an action or specify the execute
|
||||
// action then follow the actual default execute action
|
||||
if (action == null || Action.execute.equals(action)) {
|
||||
action = command.getExecuteAction();
|
||||
}
|
||||
|
||||
// Check that the specified action was previously
|
||||
// offered
|
||||
if (!command.isValidAction(action)) {
|
||||
respondError(response, XMPPError.Condition.bad_request,
|
||||
AdHocCommand.SpecificErrorCondition.badAction);
|
||||
return;
|
||||
}
|
||||
|
||||
try {
|
||||
// TODO: Check that all the required fields of the form are
|
||||
// TODO: filled, if not throw an exception. This will simplify the
|
||||
// TODO: construction of new commands
|
||||
|
||||
// Since all errors were passed, the response is now a
|
||||
// result
|
||||
response.setType(IQ.Type.RESULT);
|
||||
|
||||
// Set the new data to the command.
|
||||
command.setData(response);
|
||||
|
||||
if (Action.next.equals(action)) {
|
||||
command.incrementStage();
|
||||
command.next(new Form(requestData.getForm()));
|
||||
if (command.isLastStage()) {
|
||||
// If it is the last stage then the command is
|
||||
// completed
|
||||
response.setStatus(Status.completed);
|
||||
}
|
||||
else {
|
||||
// Otherwise it is still executing
|
||||
response.setStatus(Status.executing);
|
||||
}
|
||||
}
|
||||
else if (Action.complete.equals(action)) {
|
||||
command.incrementStage();
|
||||
command.complete(new Form(requestData.getForm()));
|
||||
response.setStatus(Status.completed);
|
||||
// Remove the completed session
|
||||
executingCommands.remove(sessionId);
|
||||
}
|
||||
else if (Action.prev.equals(action)) {
|
||||
command.decrementStage();
|
||||
command.prev();
|
||||
}
|
||||
else if (Action.cancel.equals(action)) {
|
||||
command.cancel();
|
||||
response.setStatus(Status.canceled);
|
||||
// Remove the canceled session
|
||||
executingCommands.remove(sessionId);
|
||||
}
|
||||
|
||||
connection().sendPacket(response);
|
||||
}
|
||||
catch (XMPPErrorException e) {
|
||||
// If there is an exception caused by the next, complete,
|
||||
// prev or cancel method, then that error is returned to the
|
||||
// requester.
|
||||
XMPPError error = e.getXMPPError();
|
||||
|
||||
// If the error type is cancel, then the execution is
|
||||
// canceled therefore the status must show that, and the
|
||||
// command be removed from the executing list.
|
||||
if (XMPPError.Type.CANCEL.equals(error.getType())) {
|
||||
response.setStatus(Status.canceled);
|
||||
executingCommands.remove(sessionId);
|
||||
}
|
||||
respondError(response, error);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Responds an error with an specific condition.
|
||||
*
|
||||
* @param response the response to send.
|
||||
* @param condition the condition of the error.
|
||||
* @throws NotConnectedException
|
||||
*/
|
||||
private void respondError(AdHocCommandData response,
|
||||
XMPPError.Condition condition) throws NotConnectedException {
|
||||
respondError(response, new XMPPError(condition));
|
||||
}
|
||||
|
||||
/**
|
||||
* Responds an error with an specific condition.
|
||||
*
|
||||
* @param response the response to send.
|
||||
* @param condition the condition of the error.
|
||||
* @param specificCondition the adhoc command error condition.
|
||||
* @throws NotConnectedException
|
||||
*/
|
||||
private void respondError(AdHocCommandData response, XMPPError.Condition condition,
|
||||
AdHocCommand.SpecificErrorCondition specificCondition) throws NotConnectedException
|
||||
{
|
||||
XMPPError error = new XMPPError(condition);
|
||||
error.addExtension(new AdHocCommandData.SpecificError(specificCondition));
|
||||
respondError(response, error);
|
||||
}
|
||||
|
||||
/**
|
||||
* Responds an error with an specific error.
|
||||
*
|
||||
* @param response the response to send.
|
||||
* @param error the error to send.
|
||||
* @throws NotConnectedException
|
||||
*/
|
||||
private void respondError(AdHocCommandData response, XMPPError error) throws NotConnectedException {
|
||||
response.setType(IQ.Type.ERROR);
|
||||
response.setError(error);
|
||||
connection().sendPacket(response);
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a new instance of a command to be used by a new execution request
|
||||
*
|
||||
* @param commandNode the command node that identifies it.
|
||||
* @param sessionID the session id of this execution.
|
||||
* @return the command instance to execute.
|
||||
* @throws XMPPErrorException if there is problem creating the new instance.
|
||||
*/
|
||||
private LocalCommand newInstanceOfCmd(String commandNode, String sessionID) throws XMPPErrorException
|
||||
{
|
||||
AdHocCommandInfo commandInfo = commands.get(commandNode);
|
||||
LocalCommand command;
|
||||
try {
|
||||
command = (LocalCommand) commandInfo.getCommandInstance();
|
||||
command.setSessionID(sessionID);
|
||||
command.setName(commandInfo.getName());
|
||||
command.setNode(commandInfo.getNode());
|
||||
}
|
||||
catch (InstantiationException e) {
|
||||
throw new XMPPErrorException(new XMPPError(
|
||||
XMPPError.Condition.internal_server_error));
|
||||
}
|
||||
catch (IllegalAccessException e) {
|
||||
throw new XMPPErrorException(new XMPPError(
|
||||
XMPPError.Condition.internal_server_error));
|
||||
}
|
||||
return command;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the registered commands of this command manager, which is related
|
||||
* to a connection.
|
||||
*
|
||||
* @return the registered commands.
|
||||
*/
|
||||
private Collection<AdHocCommandInfo> getRegisteredCommands() {
|
||||
return commands.values();
|
||||
}
|
||||
|
||||
/**
|
||||
* Stores ad-hoc command information.
|
||||
*/
|
||||
private static class AdHocCommandInfo {
|
||||
|
||||
private String node;
|
||||
private String name;
|
||||
private String ownerJID;
|
||||
private LocalCommandFactory factory;
|
||||
|
||||
public AdHocCommandInfo(String node, String name, String ownerJID,
|
||||
LocalCommandFactory factory)
|
||||
{
|
||||
this.node = node;
|
||||
this.name = name;
|
||||
this.ownerJID = ownerJID;
|
||||
this.factory = factory;
|
||||
}
|
||||
|
||||
public LocalCommand getCommandInstance() throws InstantiationException,
|
||||
IllegalAccessException
|
||||
{
|
||||
return factory.getInstance();
|
||||
}
|
||||
|
||||
public String getName() {
|
||||
return name;
|
||||
}
|
||||
|
||||
public String getNode() {
|
||||
return node;
|
||||
}
|
||||
|
||||
public String getOwnerJID() {
|
||||
return ownerJID;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,83 @@
|
|||
/**
|
||||
*
|
||||
* Copyright 2005-2007 Jive Software.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
package org.jivesoftware.smackx.commands;
|
||||
|
||||
/**
|
||||
* Notes can be added to a command execution response. A note has a type and value.
|
||||
*
|
||||
* @author Gabriel Guardincerri
|
||||
*/
|
||||
public class AdHocCommandNote {
|
||||
|
||||
private Type type;
|
||||
private String value;
|
||||
|
||||
/**
|
||||
* Creates a new adhoc command note with the specified type and value.
|
||||
*
|
||||
* @param type the type of the note.
|
||||
* @param value the value of the note.
|
||||
*/
|
||||
public AdHocCommandNote(Type type, String value) {
|
||||
this.type = type;
|
||||
this.value = value;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the value or message of the note.
|
||||
*
|
||||
* @return the value or message of the note.
|
||||
*/
|
||||
public String getValue() {
|
||||
return value;
|
||||
}
|
||||
|
||||
/**
|
||||
* Return the type of the note.
|
||||
*
|
||||
* @return the type of the note.
|
||||
*/
|
||||
public Type getType() {
|
||||
return type;
|
||||
}
|
||||
|
||||
/**
|
||||
* Represents a note type.
|
||||
*/
|
||||
public enum Type {
|
||||
|
||||
/**
|
||||
* The note is informational only. This is not really an exceptional
|
||||
* condition.
|
||||
*/
|
||||
info,
|
||||
|
||||
/**
|
||||
* The note indicates a warning. Possibly due to illogical (yet valid)
|
||||
* data.
|
||||
*/
|
||||
warn,
|
||||
|
||||
/**
|
||||
* The note indicates an error. The text should indicate the reason for
|
||||
* the error.
|
||||
*/
|
||||
error
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,166 @@
|
|||
/**
|
||||
*
|
||||
* Copyright 2005-2007 Jive Software.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
package org.jivesoftware.smackx.commands;
|
||||
|
||||
import org.jivesoftware.smackx.commands.packet.AdHocCommandData;
|
||||
|
||||
/**
|
||||
* Represents a command that can be executed locally from a remote location. This
|
||||
* class must be extended to implement an specific ad-hoc command. This class
|
||||
* provides some useful tools:<ul>
|
||||
* <li>Node</li>
|
||||
* <li>Name</li>
|
||||
* <li>Session ID</li>
|
||||
* <li>Current Stage</li>
|
||||
* <li>Available actions</li>
|
||||
* <li>Default action</li>
|
||||
* </ul><p/>
|
||||
* To implement a new command extend this class and implement all the abstract
|
||||
* methods. When implementing the actions remember that they could be invoked
|
||||
* several times, and that you must use the current stage number to know what to
|
||||
* do.
|
||||
*
|
||||
* @author Gabriel Guardincerri
|
||||
*/
|
||||
public abstract class LocalCommand extends AdHocCommand {
|
||||
|
||||
/**
|
||||
* The time stamp of first invokation of the command. Used to implement the session timeout.
|
||||
*/
|
||||
private long creationDate;
|
||||
|
||||
/**
|
||||
* The unique ID of the execution of the command.
|
||||
*/
|
||||
private String sessionID;
|
||||
|
||||
/**
|
||||
* The full JID of the host of the command.
|
||||
*/
|
||||
private String ownerJID;
|
||||
|
||||
/**
|
||||
* The number of the current stage.
|
||||
*/
|
||||
private int currenStage;
|
||||
|
||||
public LocalCommand() {
|
||||
super();
|
||||
this.creationDate = System.currentTimeMillis();
|
||||
currenStage = -1;
|
||||
}
|
||||
|
||||
/**
|
||||
* The sessionID is an unique identifier of an execution request. This is
|
||||
* automatically handled and should not be called.
|
||||
*
|
||||
* @param sessionID the unique session id of this execution
|
||||
*/
|
||||
public void setSessionID(String sessionID) {
|
||||
this.sessionID = sessionID;
|
||||
getData().setSessionID(sessionID);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the session ID of this execution.
|
||||
*
|
||||
* @return the unique session id of this execution
|
||||
*/
|
||||
public String getSessionID() {
|
||||
return sessionID;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the JID of the command host. This is automatically handled and should
|
||||
* not be called.
|
||||
*
|
||||
* @param ownerJID the JID of the owner.
|
||||
*/
|
||||
public void setOwnerJID(String ownerJID) {
|
||||
this.ownerJID = ownerJID;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getOwnerJID() {
|
||||
return ownerJID;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the date the command was created.
|
||||
*
|
||||
* @return the date the command was created.
|
||||
*/
|
||||
public long getCreationDate() {
|
||||
return creationDate;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns true if the current stage is the last one. If it is then the
|
||||
* execution of some action will complete the execution of the command.
|
||||
* Commands that don't have multiple stages can always return <tt>true</tt>.
|
||||
*
|
||||
* @return true if the command is in the last stage.
|
||||
*/
|
||||
public abstract boolean isLastStage();
|
||||
|
||||
/**
|
||||
* Returns true if the specified requester has permission to execute all the
|
||||
* stages of this action. This is checked when the first request is received,
|
||||
* if the permission is grant then the requester will be able to execute
|
||||
* all the stages of the command. It is not checked again during the
|
||||
* execution.
|
||||
*
|
||||
* @param jid the JID to check permissions on.
|
||||
* @return true if the user has permission to execute this action.
|
||||
*/
|
||||
public abstract boolean hasPermission(String jid);
|
||||
|
||||
/**
|
||||
* Returns the currently executing stage number. The first stage number is
|
||||
* 0. During the execution of the first action this method will answer 0.
|
||||
*
|
||||
* @return the current stage number.
|
||||
*/
|
||||
public int getCurrentStage() {
|
||||
return currenStage;
|
||||
}
|
||||
|
||||
@Override
|
||||
void setData(AdHocCommandData data) {
|
||||
data.setSessionID(sessionID);
|
||||
super.setData(data);
|
||||
}
|
||||
|
||||
/**
|
||||
* Increase the current stage number. This is automatically handled and should
|
||||
* not be called.
|
||||
*
|
||||
*/
|
||||
void incrementStage() {
|
||||
currenStage++;
|
||||
}
|
||||
|
||||
/**
|
||||
* Decrease the current stage number. This is automatically handled and should
|
||||
* not be called.
|
||||
*
|
||||
*/
|
||||
void decrementStage() {
|
||||
currenStage--;
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,40 @@
|
|||
/**
|
||||
*
|
||||
* Copyright 2008 Jive Software.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
package org.jivesoftware.smackx.commands;
|
||||
|
||||
/**
|
||||
* A factory for creating local commands. It's useful in cases where instantiation
|
||||
* of a command is more complicated than just using the default constructor. For example,
|
||||
* when arguments must be passed into the constructor or when using a dependency injection
|
||||
* framework. When a LocalCommandFactory isn't used, you can provide the AdHocCommandManager
|
||||
* a Class object instead. For more details, see
|
||||
* {@link AdHocCommandManager#registerCommand(String, String, LocalCommandFactory)}.
|
||||
*
|
||||
* @author Matt Tucker
|
||||
*/
|
||||
public interface LocalCommandFactory {
|
||||
|
||||
/**
|
||||
* Returns an instance of a LocalCommand.
|
||||
*
|
||||
* @return a LocalCommand instance.
|
||||
* @throws InstantiationException if creating an instance failed.
|
||||
* @throws IllegalAccessException if creating an instance is not allowed.
|
||||
*/
|
||||
public LocalCommand getInstance() throws InstantiationException, IllegalAccessException;
|
||||
|
||||
}
|
||||
|
|
@ -0,0 +1,154 @@
|
|||
/**
|
||||
*
|
||||
* Copyright 2005-2007 Jive Software.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
package org.jivesoftware.smackx.commands;
|
||||
|
||||
import org.jivesoftware.smack.SmackException.NoResponseException;
|
||||
import org.jivesoftware.smack.SmackException.NotConnectedException;
|
||||
import org.jivesoftware.smack.XMPPConnection;
|
||||
import org.jivesoftware.smack.XMPPException.XMPPErrorException;
|
||||
import org.jivesoftware.smack.packet.IQ;
|
||||
import org.jivesoftware.smackx.commands.packet.AdHocCommandData;
|
||||
import org.jivesoftware.smackx.xdata.Form;
|
||||
|
||||
/**
|
||||
* Represents a command that is in a remote location. Invoking one of the
|
||||
* {@link AdHocCommand.Action#execute execute}, {@link AdHocCommand.Action#next next},
|
||||
* {@link AdHocCommand.Action#prev prev}, {@link AdHocCommand.Action#cancel cancel} or
|
||||
* {@link AdHocCommand.Action#complete complete} actions results in executing that
|
||||
* action in the remote location. In response to that action the internal state
|
||||
* of the this command instance will change. For example, if the command is a
|
||||
* single stage command, then invoking the execute action will execute this
|
||||
* action in the remote location. After that the local instance will have a
|
||||
* state of "completed" and a form or notes that applies.
|
||||
*
|
||||
* @author Gabriel Guardincerri
|
||||
*
|
||||
*/
|
||||
public class RemoteCommand extends AdHocCommand {
|
||||
|
||||
/**
|
||||
* The connection that is used to execute this command
|
||||
*/
|
||||
private XMPPConnection connection;
|
||||
|
||||
/**
|
||||
* The full JID of the command host
|
||||
*/
|
||||
private String jid;
|
||||
|
||||
/**
|
||||
* The session ID of this execution.
|
||||
*/
|
||||
private String sessionID;
|
||||
|
||||
/**
|
||||
* Creates a new RemoteCommand that uses an specific connection to execute a
|
||||
* command identified by <code>node</code> in the host identified by
|
||||
* <code>jid</code>
|
||||
*
|
||||
* @param connection the connection to use for the execution.
|
||||
* @param node the identifier of the command.
|
||||
* @param jid the JID of the host.
|
||||
*/
|
||||
protected RemoteCommand(XMPPConnection connection, String node, String jid) {
|
||||
super();
|
||||
this.connection = connection;
|
||||
this.jid = jid;
|
||||
this.setNode(node);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void cancel() throws NoResponseException, XMPPErrorException, NotConnectedException {
|
||||
executeAction(Action.cancel);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void complete(Form form) throws NoResponseException, XMPPErrorException, NotConnectedException {
|
||||
executeAction(Action.complete, form);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void execute() throws NoResponseException, XMPPErrorException, NotConnectedException {
|
||||
executeAction(Action.execute);
|
||||
}
|
||||
|
||||
/**
|
||||
* Executes the default action of the command with the information provided
|
||||
* in the Form. This form must be the anwser form of the previous stage. If
|
||||
* there is a problem executing the command it throws an XMPPException.
|
||||
*
|
||||
* @param form the form anwser of the previous stage.
|
||||
* @throws XMPPErrorException if an error occurs.
|
||||
* @throws NoResponseException if there was no response from the server.
|
||||
* @throws NotConnectedException
|
||||
*/
|
||||
public void execute(Form form) throws NoResponseException, XMPPErrorException, NotConnectedException {
|
||||
executeAction(Action.execute, form);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void next(Form form) throws NoResponseException, XMPPErrorException, NotConnectedException {
|
||||
executeAction(Action.next, form);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void prev() throws NoResponseException, XMPPErrorException, NotConnectedException {
|
||||
executeAction(Action.prev);
|
||||
}
|
||||
|
||||
private void executeAction(Action action) throws NoResponseException, XMPPErrorException, NotConnectedException {
|
||||
executeAction(action, null);
|
||||
}
|
||||
|
||||
/**
|
||||
* Executes the <code>action</codo> with the <code>form</code>.
|
||||
* The action could be any of the available actions. The form must
|
||||
* be the anwser of the previous stage. It can be <tt>null</tt> if it is the first stage.
|
||||
*
|
||||
* @param action the action to execute.
|
||||
* @param form the form with the information.
|
||||
* @throws XMPPErrorException if there is a problem executing the command.
|
||||
* @throws NoResponseException if there was no response from the server.
|
||||
* @throws NotConnectedException
|
||||
*/
|
||||
private void executeAction(Action action, Form form) throws NoResponseException, XMPPErrorException, NotConnectedException {
|
||||
// TODO: Check that all the required fields of the form were filled, if
|
||||
// TODO: not throw the corresponding exeption. This will make a faster response,
|
||||
// TODO: since the request is stoped before it's sent.
|
||||
AdHocCommandData data = new AdHocCommandData();
|
||||
data.setType(IQ.Type.SET);
|
||||
data.setTo(getOwnerJID());
|
||||
data.setNode(getNode());
|
||||
data.setSessionID(sessionID);
|
||||
data.setAction(action);
|
||||
|
||||
if (form != null) {
|
||||
data.setForm(form.getDataFormToSend());
|
||||
}
|
||||
|
||||
AdHocCommandData responseData = (AdHocCommandData) connection.createPacketCollectorAndSend(
|
||||
data).nextResultOrThrow();
|
||||
|
||||
this.sessionID = responseData.getSessionID();
|
||||
super.setData(responseData);
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getOwnerJID() {
|
||||
return jid;
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,277 @@
|
|||
/**
|
||||
*
|
||||
* Copyright 2005-2008 Jive Software.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
package org.jivesoftware.smackx.commands.packet;
|
||||
|
||||
import org.jivesoftware.smack.packet.IQ;
|
||||
import org.jivesoftware.smack.packet.PacketExtension;
|
||||
import org.jivesoftware.smackx.commands.AdHocCommand;
|
||||
import org.jivesoftware.smackx.commands.AdHocCommand.Action;
|
||||
import org.jivesoftware.smackx.commands.AdHocCommand.SpecificErrorCondition;
|
||||
import org.jivesoftware.smackx.commands.AdHocCommandNote;
|
||||
import org.jivesoftware.smackx.xdata.packet.DataForm;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
/**
|
||||
* Represents the state and the request of the execution of an adhoc command.
|
||||
*
|
||||
* @author Gabriel Guardincerri
|
||||
*/
|
||||
public class AdHocCommandData extends IQ {
|
||||
|
||||
/* JID of the command host */
|
||||
private String id;
|
||||
|
||||
/* Command name */
|
||||
private String name;
|
||||
|
||||
/* Command identifier */
|
||||
private String node;
|
||||
|
||||
/* Unique ID of the execution */
|
||||
private String sessionID;
|
||||
|
||||
private List<AdHocCommandNote> notes = new ArrayList<AdHocCommandNote>();
|
||||
|
||||
private DataForm form;
|
||||
|
||||
/* Action request to be executed */
|
||||
private AdHocCommand.Action action;
|
||||
|
||||
/* Current execution status */
|
||||
private AdHocCommand.Status status;
|
||||
|
||||
private ArrayList<AdHocCommand.Action> actions = new ArrayList<AdHocCommand.Action>();
|
||||
|
||||
private AdHocCommand.Action executeAction;
|
||||
|
||||
private String lang;
|
||||
|
||||
public AdHocCommandData() {
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getChildElementXML() {
|
||||
StringBuilder buf = new StringBuilder();
|
||||
buf.append("<command xmlns=\"http://jabber.org/protocol/commands\"");
|
||||
buf.append(" node=\"").append(node).append("\"");
|
||||
if (sessionID != null) {
|
||||
if (!sessionID.equals("")) {
|
||||
buf.append(" sessionid=\"").append(sessionID).append("\"");
|
||||
}
|
||||
}
|
||||
if (status != null) {
|
||||
buf.append(" status=\"").append(status).append("\"");
|
||||
}
|
||||
if (action != null) {
|
||||
buf.append(" action=\"").append(action).append("\"");
|
||||
}
|
||||
|
||||
if (lang != null) {
|
||||
if (!lang.equals("")) {
|
||||
buf.append(" lang=\"").append(lang).append("\"");
|
||||
}
|
||||
}
|
||||
buf.append(">");
|
||||
|
||||
if (getType() == Type.RESULT) {
|
||||
buf.append("<actions");
|
||||
|
||||
if (executeAction != null) {
|
||||
buf.append(" execute=\"").append(executeAction).append("\"");
|
||||
}
|
||||
if (actions.size() == 0) {
|
||||
buf.append("/>");
|
||||
} else {
|
||||
buf.append(">");
|
||||
|
||||
for (AdHocCommand.Action action : actions) {
|
||||
buf.append("<").append(action).append("/>");
|
||||
}
|
||||
buf.append("</actions>");
|
||||
}
|
||||
}
|
||||
|
||||
if (form != null) {
|
||||
buf.append(form.toXML());
|
||||
}
|
||||
|
||||
for (AdHocCommandNote note : notes) {
|
||||
buf.append("<note type=\"").append(note.getType().toString()).append("\">");
|
||||
buf.append(note.getValue());
|
||||
buf.append("</note>");
|
||||
}
|
||||
|
||||
// TODO ERRORS
|
||||
// if (getError() != null) {
|
||||
// buf.append(getError().toXML());
|
||||
// }
|
||||
|
||||
buf.append("</command>");
|
||||
return buf.toString();
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the JID of the command host.
|
||||
*
|
||||
* @return the JID of the command host.
|
||||
*/
|
||||
public String getId() {
|
||||
return id;
|
||||
}
|
||||
|
||||
public void setId(String id) {
|
||||
this.id = id;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the human name of the command
|
||||
*
|
||||
* @return the name of the command.
|
||||
*/
|
||||
public String getName() {
|
||||
return name;
|
||||
}
|
||||
|
||||
public void setName(String name) {
|
||||
this.name = name;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the identifier of the command
|
||||
*
|
||||
* @return the node.
|
||||
*/
|
||||
public String getNode() {
|
||||
return node;
|
||||
}
|
||||
|
||||
public void setNode(String node) {
|
||||
this.node = node;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the list of notes that the command has.
|
||||
*
|
||||
* @return the notes.
|
||||
*/
|
||||
public List<AdHocCommandNote> getNotes() {
|
||||
return notes;
|
||||
}
|
||||
|
||||
public void addNote(AdHocCommandNote note) {
|
||||
this.notes.add(note);
|
||||
}
|
||||
|
||||
public void remveNote(AdHocCommandNote note) {
|
||||
this.notes.remove(note);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the form of the command.
|
||||
*
|
||||
* @return the data form associated with the command.
|
||||
*/
|
||||
public DataForm getForm() {
|
||||
return form;
|
||||
}
|
||||
|
||||
public void setForm(DataForm form) {
|
||||
this.form = form;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the action to execute. The action is set only on a request.
|
||||
*
|
||||
* @return the action to execute.
|
||||
*/
|
||||
public AdHocCommand.Action getAction() {
|
||||
return action;
|
||||
}
|
||||
|
||||
public void setAction(AdHocCommand.Action action) {
|
||||
this.action = action;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the status of the execution.
|
||||
*
|
||||
* @return the status.
|
||||
*/
|
||||
public AdHocCommand.Status getStatus() {
|
||||
return status;
|
||||
}
|
||||
|
||||
public void setStatus(AdHocCommand.Status status) {
|
||||
this.status = status;
|
||||
}
|
||||
|
||||
public List<Action> getActions() {
|
||||
return actions;
|
||||
}
|
||||
|
||||
public void addAction(Action action) {
|
||||
actions.add(action);
|
||||
}
|
||||
|
||||
public void setExecuteAction(Action executeAction) {
|
||||
this.executeAction = executeAction;
|
||||
}
|
||||
|
||||
public Action getExecuteAction() {
|
||||
return executeAction;
|
||||
}
|
||||
|
||||
public void setSessionID(String sessionID) {
|
||||
this.sessionID = sessionID;
|
||||
}
|
||||
|
||||
public String getSessionID() {
|
||||
return sessionID;
|
||||
}
|
||||
|
||||
public static class SpecificError implements PacketExtension {
|
||||
|
||||
public static final String namespace = "http://jabber.org/protocol/commands";
|
||||
|
||||
public SpecificErrorCondition condition;
|
||||
|
||||
public SpecificError(SpecificErrorCondition condition) {
|
||||
this.condition = condition;
|
||||
}
|
||||
|
||||
public String getElementName() {
|
||||
return condition.toString();
|
||||
}
|
||||
public String getNamespace() {
|
||||
return namespace;
|
||||
}
|
||||
|
||||
public SpecificErrorCondition getCondition() {
|
||||
return condition;
|
||||
}
|
||||
|
||||
public String toXML() {
|
||||
StringBuilder buf = new StringBuilder();
|
||||
buf.append("<").append(getElementName());
|
||||
buf.append(" xmlns=\"").append(getNamespace()).append("\"/>");
|
||||
return buf.toString();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,153 @@
|
|||
/**
|
||||
*
|
||||
* Copyright 2005-2007 Jive Software.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
package org.jivesoftware.smackx.commands.provider;
|
||||
|
||||
import org.jivesoftware.smack.packet.IQ;
|
||||
import org.jivesoftware.smack.packet.PacketExtension;
|
||||
import org.jivesoftware.smack.packet.XMPPError;
|
||||
import org.jivesoftware.smack.provider.IQProvider;
|
||||
import org.jivesoftware.smack.provider.PacketExtensionProvider;
|
||||
import org.jivesoftware.smack.util.PacketParserUtils;
|
||||
import org.jivesoftware.smackx.commands.AdHocCommand;
|
||||
import org.jivesoftware.smackx.commands.AdHocCommand.Action;
|
||||
import org.jivesoftware.smackx.commands.packet.AdHocCommandData;
|
||||
import org.jivesoftware.smackx.commands.AdHocCommandNote;
|
||||
import org.jivesoftware.smackx.xdata.packet.DataForm;
|
||||
import org.jivesoftware.smackx.xdata.provider.DataFormProvider;
|
||||
import org.xmlpull.v1.XmlPullParser;
|
||||
|
||||
/**
|
||||
* The AdHocCommandDataProvider parses AdHocCommandData packets.
|
||||
*
|
||||
* @author Gabriel Guardincerri
|
||||
*/
|
||||
public class AdHocCommandDataProvider implements IQProvider {
|
||||
|
||||
public IQ parseIQ(XmlPullParser parser) throws Exception {
|
||||
boolean done = false;
|
||||
AdHocCommandData adHocCommandData = new AdHocCommandData();
|
||||
DataFormProvider dataFormProvider = new DataFormProvider();
|
||||
|
||||
int eventType;
|
||||
String elementName;
|
||||
String namespace;
|
||||
adHocCommandData.setSessionID(parser.getAttributeValue("", "sessionid"));
|
||||
adHocCommandData.setNode(parser.getAttributeValue("", "node"));
|
||||
|
||||
// Status
|
||||
String status = parser.getAttributeValue("", "status");
|
||||
if (AdHocCommand.Status.executing.toString().equalsIgnoreCase(status)) {
|
||||
adHocCommandData.setStatus(AdHocCommand.Status.executing);
|
||||
}
|
||||
else if (AdHocCommand.Status.completed.toString().equalsIgnoreCase(status)) {
|
||||
adHocCommandData.setStatus(AdHocCommand.Status.completed);
|
||||
}
|
||||
else if (AdHocCommand.Status.canceled.toString().equalsIgnoreCase(status)) {
|
||||
adHocCommandData.setStatus(AdHocCommand.Status.canceled);
|
||||
}
|
||||
|
||||
// Action
|
||||
String action = parser.getAttributeValue("", "action");
|
||||
if (action != null) {
|
||||
Action realAction = AdHocCommand.Action.valueOf(action);
|
||||
if (realAction == null || realAction.equals(Action.unknown)) {
|
||||
adHocCommandData.setAction(Action.unknown);
|
||||
}
|
||||
else {
|
||||
adHocCommandData.setAction(realAction);
|
||||
}
|
||||
}
|
||||
while (!done) {
|
||||
eventType = parser.next();
|
||||
elementName = parser.getName();
|
||||
namespace = parser.getNamespace();
|
||||
if (eventType == XmlPullParser.START_TAG) {
|
||||
if (parser.getName().equals("actions")) {
|
||||
String execute = parser.getAttributeValue("", "execute");
|
||||
if (execute != null) {
|
||||
adHocCommandData.setExecuteAction(AdHocCommand.Action.valueOf(execute));
|
||||
}
|
||||
}
|
||||
else if (parser.getName().equals("next")) {
|
||||
adHocCommandData.addAction(AdHocCommand.Action.next);
|
||||
}
|
||||
else if (parser.getName().equals("complete")) {
|
||||
adHocCommandData.addAction(AdHocCommand.Action.complete);
|
||||
}
|
||||
else if (parser.getName().equals("prev")) {
|
||||
adHocCommandData.addAction(AdHocCommand.Action.prev);
|
||||
}
|
||||
else if (elementName.equals("x") && namespace.equals("jabber:x:data")) {
|
||||
adHocCommandData.setForm((DataForm) dataFormProvider.parseExtension(parser));
|
||||
}
|
||||
else if (parser.getName().equals("note")) {
|
||||
AdHocCommandNote.Type type = AdHocCommandNote.Type.valueOf(
|
||||
parser.getAttributeValue("", "type"));
|
||||
String value = parser.nextText();
|
||||
adHocCommandData.addNote(new AdHocCommandNote(type, value));
|
||||
}
|
||||
else if (parser.getName().equals("error")) {
|
||||
XMPPError error = PacketParserUtils.parseError(parser);
|
||||
adHocCommandData.setError(error);
|
||||
}
|
||||
}
|
||||
else if (eventType == XmlPullParser.END_TAG) {
|
||||
if (parser.getName().equals("command")) {
|
||||
done = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
return adHocCommandData;
|
||||
}
|
||||
|
||||
public static class BadActionError implements PacketExtensionProvider {
|
||||
public PacketExtension parseExtension(XmlPullParser parser) throws Exception {
|
||||
return new AdHocCommandData.SpecificError(AdHocCommand.SpecificErrorCondition.badAction);
|
||||
}
|
||||
}
|
||||
|
||||
public static class MalformedActionError implements PacketExtensionProvider {
|
||||
public PacketExtension parseExtension(XmlPullParser parser) throws Exception {
|
||||
return new AdHocCommandData.SpecificError(AdHocCommand.SpecificErrorCondition.malformedAction);
|
||||
}
|
||||
}
|
||||
|
||||
public static class BadLocaleError implements PacketExtensionProvider {
|
||||
public PacketExtension parseExtension(XmlPullParser parser) throws Exception {
|
||||
return new AdHocCommandData.SpecificError(AdHocCommand.SpecificErrorCondition.badLocale);
|
||||
}
|
||||
}
|
||||
|
||||
public static class BadPayloadError implements PacketExtensionProvider {
|
||||
public PacketExtension parseExtension(XmlPullParser parser) throws Exception {
|
||||
return new AdHocCommandData.SpecificError(AdHocCommand.SpecificErrorCondition.badPayload);
|
||||
}
|
||||
}
|
||||
|
||||
public static class BadSessionIDError implements PacketExtensionProvider {
|
||||
public PacketExtension parseExtension(XmlPullParser parser) throws Exception {
|
||||
return new AdHocCommandData.SpecificError(AdHocCommand.SpecificErrorCondition.badSessionid);
|
||||
}
|
||||
}
|
||||
|
||||
public static class SessionExpiredError implements PacketExtensionProvider {
|
||||
public PacketExtension parseExtension(XmlPullParser parser) throws Exception {
|
||||
return new AdHocCommandData.SpecificError(AdHocCommand.SpecificErrorCondition.sessionExpired);
|
||||
}
|
||||
}
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue