Java tutorial
/* * TeleStax, Open Source Cloud Communications * Copyright 2011-2016, Telestax Inc and individual contributors * by the @authors tag. * * This is free software; you can redistribute it and/or modify it * under the terms of the GNU Lesser General Public License as * published by the Free Software Foundation; either version 2.1 of * the License, or (at your option) any later version. * * This software is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this software; if not, write to the Free * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA * 02110-1301 USA, or see the FSF site: http://www.fsf.org. */ package org.restcomm.media.control.mgcp.command; import org.apache.log4j.Logger; import org.restcomm.media.control.mgcp.connection.MgcpConnection; import org.restcomm.media.control.mgcp.connection.MgcpLocalConnection; import org.restcomm.media.control.mgcp.endpoint.MgcpEndpoint; import org.restcomm.media.control.mgcp.endpoint.MgcpEndpointManager; import org.restcomm.media.control.mgcp.exception.MgcpCallNotFoundException; import org.restcomm.media.control.mgcp.exception.MgcpConnectionException; import org.restcomm.media.control.mgcp.exception.MgcpConnectionNotFoundException; import org.restcomm.media.control.mgcp.exception.MgcpException; import org.restcomm.media.control.mgcp.exception.UnrecognizedMgcpNamespaceException; import org.restcomm.media.control.mgcp.message.LocalConnectionOptions; import org.restcomm.media.control.mgcp.message.MgcpParameterType; import org.restcomm.media.control.mgcp.message.MgcpResponseCode; import org.restcomm.media.control.mgcp.util.collections.Parameters; import org.restcomm.media.spi.ConnectionMode; import com.google.common.base.Optional; /** * This command is used to create a connection between two endpoints. * * @author Henrique Rosa (henrique.rosa@telestax.com) * */ public class CreateConnectionCommand extends AbstractMgcpCommand { private static final Logger log = Logger.getLogger(CreateConnectionCommand.class); protected static final String WILDCARD_ALL = "*"; protected static final String WILDCARD_ANY = "$"; protected static final String ENDPOINT_ID_SEPARATOR = "@"; public CreateConnectionCommand(int transactionId, Parameters<MgcpParameterType> parameters, MgcpEndpointManager endpointManager) { super(transactionId, parameters, endpointManager); } private int loadCallId(Parameters<MgcpParameterType> parameters) throws MgcpCommandException { // Call ID Optional<Integer> callId = parameters.getIntegerBase16(MgcpParameterType.CALL_ID); if (!callId.isPresent()) { throw new MgcpCommandException(MgcpResponseCode.INCORRECT_CALL_ID); } return callId.get(); } private String loadEndpointId(Parameters<MgcpParameterType> parameters) throws MgcpCommandException { Optional<String> endpointId = parameters.getString(MgcpParameterType.ENDPOINT_ID); if (!endpointId.isPresent()) { throw new MgcpCommandException(MgcpResponseCode.ENDPOINT_UNKNOWN); } if (endpointId.get().indexOf(WILDCARD_ALL) != -1) { throw new MgcpCommandException(MgcpResponseCode.WILDCARD_TOO_COMPLICATED); } return endpointId.get(); } private String loadSecondEndpointId(Parameters<MgcpParameterType> parameters) throws MgcpCommandException { Optional<String> secondEndpointId = parameters.getString(MgcpParameterType.SECOND_ENDPOINT); if (secondEndpointId.isPresent()) { if (secondEndpointId.get().indexOf(WILDCARD_ALL) != -1) { throw new MgcpCommandException(MgcpResponseCode.WILDCARD_TOO_COMPLICATED); } } return secondEndpointId.or(""); } private String loadRemoteDescription(Parameters<MgcpParameterType> parameters) throws MgcpCommandException { Optional<String> remoteSdp = parameters.getString(MgcpParameterType.SDP); Optional<String> secondEndpointId = parameters.getString(MgcpParameterType.SECOND_ENDPOINT); if (secondEndpointId.isPresent() && remoteSdp.isPresent()) { throw new MgcpCommandException(MgcpResponseCode.PROTOCOL_ERROR.code(), "Z2 and SDP present in message"); } return remoteSdp.or(""); } private ConnectionMode loadConnectionMode(Parameters<MgcpParameterType> parameters) throws MgcpCommandException { Optional<String> mode = parameters.getString(MgcpParameterType.MODE); try { if (!mode.isPresent()) { throw new MgcpCommandException(MgcpResponseCode.INVALID_OR_UNSUPPORTED_MODE); } else { return ConnectionMode.fromDescription(mode.get()); } } catch (IllegalArgumentException e) { throw new MgcpCommandException(MgcpResponseCode.INVALID_OR_UNSUPPORTED_MODE); } } private MgcpEndpoint retrieveEndpoint(String endpointId) throws MgcpCommandException { // Get local name final int indexOfSeparator = endpointId.indexOf(ENDPOINT_ID_SEPARATOR); final String localName = endpointId.substring(0, indexOfSeparator); final MgcpEndpoint endpoint; final int indexOfAll = endpointId.indexOf(WILDCARD_ANY); if (indexOfAll == -1) { // Search for registered endpoint endpoint = this.endpointManager.getEndpoint(endpointId); if (endpoint == null) { throw new MgcpCommandException(MgcpResponseCode.ENDPOINT_UNKNOWN); } } else { // Create new endpoint for a specific name space try { endpoint = this.endpointManager.registerEndpoint(localName.substring(0, indexOfAll)); } catch (UnrecognizedMgcpNamespaceException e) { throw new MgcpCommandException(MgcpResponseCode.ENDPOINT_NOT_AVAILABLE); } } return endpoint; } /** * Creates a new Remote Connection. * * <p> * The connection will be half-open and a Local Connection Description is generated. * </p> * * @param callId The call identifies which indicates to which session the connection belongs to. * @param mode The connection mode. * @param endpoint The endpoint where the connection will be registered to. * * @return The new connection * @throws MgcpConnectionException If connection could not be half opened. */ private MgcpConnection createRemoteConnection(int callId, ConnectionMode mode, MgcpEndpoint endpoint, CrcxContext context) throws MgcpConnectionException { // Create connection MgcpConnection connection = endpoint.createConnection(callId, false); // TODO set call agent // TODO provide local connection options String localDescription = connection.halfOpen(new LocalConnectionOptions()); context.setLocalDescription(localDescription); connection.setMode(mode); return connection; } /** * Creates a new Remote Connection. * * <p> * The connection will be fully open and connected to the remote peer.<br> * A Local Connection Description is generated. * </p> * * @param callId The the call identifies which indicates to which session the connection belongs to. * @param mode The connection mode. * @param remoteDescription The description of the remote connection. * @param endpoint The endpoint where the connection will be registered to. * * @return The new connection * @throws MgcpConnectionException If connection could not be opened */ private MgcpConnection createRemoteConnection(int callId, ConnectionMode mode, String remoteDescription, MgcpEndpoint endpoint, CrcxContext context) throws MgcpConnectionException { MgcpConnection connection = endpoint.createConnection(callId, false); // TODO set call agent String localDescription = connection.open(remoteDescription); context.setLocalDescription(localDescription); connection.setMode(mode); return connection; } /** * Creates a new Local Connection. * * <p> * The connection will be fully open and connected to a secondary endpoint.<br> * </p> * * @param callId The the call identifies which indicates to which session the connection belongs to. * @param secondEndpoint The endpoint where the connection will be registered to. * * @return The new connection * @throws MgcpException If connection could not be opened. */ private MgcpConnection createLocalConnection(int callId, MgcpEndpoint endpoint) throws MgcpConnectionException { MgcpConnection connection = endpoint.createConnection(callId, true); connection.open(null); return connection; } private void validateParameters(Parameters<MgcpParameterType> parameters, CrcxContext context) throws MgcpCommandException { context.setCallId(loadCallId(parameters)); context.setEndpointId(loadEndpointId(parameters)); context.setSecondEndpointId(loadSecondEndpointId(parameters)); context.setRemoteDescription(loadRemoteDescription(parameters)); context.setConnectionMode(loadConnectionMode(parameters)); } private void executeCommand(CrcxContext context) throws MgcpCommandException, MgcpConnectionException { // Retrieve Endpoints final String endpointId = context.getEndpointId(); final String secondEndpointId = context.getSecondEndpointId(); final MgcpEndpoint endpoint1 = retrieveEndpoint(endpointId); final MgcpEndpoint endpoint2 = secondEndpointId.isEmpty() ? null : retrieveEndpoint(secondEndpointId); // Update context with endpoint ID (in case they new endpoints were created) context.setEndpointId(endpoint1.getEndpointId().toString()); if (endpoint2 != null) { context.setSecondEndpointId(endpoint2.getEndpointId().toString()); } // Create Connections if (endpoint2 == null) { MgcpConnection connection; if (context.getRemoteDescription().isEmpty()) { // Create half-open connection connection = createRemoteConnection(context.getCallId(), context.getConnectionMode(), endpoint1, context); } else { // Create open connection connection = createRemoteConnection(context.getCallId(), context.getConnectionMode(), context.getRemoteDescription(), endpoint1, context); } // Update context with identifiers of newly created connection context.setConnectionId(connection.getIdentifier()); } else { // Create two local connections between both endpoints MgcpConnection connection1 = createLocalConnection(context.getCallId(), endpoint1); MgcpConnection connection2 = createLocalConnection(context.getCallId(), endpoint2); // Update context with identifiers of newly created connection context.setConnectionId(connection1.getIdentifier()); context.setSecondConnectionId(connection2.getIdentifier()); // Join connections ((MgcpLocalConnection) connection1).join((MgcpLocalConnection) connection2); // Set connection mode connection1.setMode(context.getConnectionMode()); connection2.setMode(ConnectionMode.SEND_RECV); } } private void rollback(CrcxContext context) { final int callId = context.getCallId(); final String endpointId = context.getEndpointId(); final String secondEndpointId = context.getSecondEndpointId(); final int connectionId = context.getConnectionId(); final int secondConnectionId = context.getSecondConnectionId(); // Retrieve Endpoints MgcpEndpoint endpoint1 = endpointId.isEmpty() ? null : this.endpointManager.getEndpoint(endpointId); MgcpEndpoint endpoint2 = secondEndpointId.isEmpty() ? null : this.endpointManager.getEndpoint(secondEndpointId); // Delete created endpoints if (endpoint1 != null && connectionId > 0) { try { endpoint1.deleteConnection(callId, connectionId); } catch (MgcpCallNotFoundException | MgcpConnectionNotFoundException e) { log.error("Could not delete primary connection. " + e.getMessage()); } } if (endpoint2 != null && secondConnectionId > 0) { try { endpoint2.deleteConnection(callId, secondConnectionId); } catch (MgcpCallNotFoundException | MgcpConnectionNotFoundException e) { log.error("Could not delete secondary connection. " + e.getMessage()); } } } private MgcpCommandResult respond(CrcxContext context) { Parameters<MgcpParameterType> parameters = new Parameters<>(); MgcpCommandResult result = new MgcpCommandResult(this.transactionId, context.getCode(), context.getMessage(), parameters); boolean successful = context.getCode() < 300; if (successful) { translateContext(context, parameters); } return result; } private void translateContext(CrcxContext context, Parameters<MgcpParameterType> parameters) { // Primary endpoint and connection final String endpointId = context.getEndpointId(); final int connectionId = context.getConnectionId(); if (!endpointId.isEmpty() && connectionId > 0) { parameters.put(MgcpParameterType.ENDPOINT_ID, endpointId); parameters.put(MgcpParameterType.CONNECTION_ID, Integer.toHexString(connectionId)); } final String secondEndpointId = context.getSecondEndpointId(); final int secondConnectionId = context.getSecondConnectionId(); if (!secondEndpointId.isEmpty() && secondConnectionId > 0) { parameters.put(MgcpParameterType.SECOND_ENDPOINT, secondEndpointId); parameters.put(MgcpParameterType.CONNECTION_ID2, Integer.toHexString(secondConnectionId)); } final String localDescription = context.getLocalDescription(); if (!localDescription.isEmpty()) { parameters.put(MgcpParameterType.SDP, localDescription); } } @Override public MgcpCommandResult call() { // Initialize empty context CrcxContext context = new CrcxContext(); try { // Validate Parameters validateParameters(this.requestParameters, context); // Execute Command executeCommand(context); context.setCode(MgcpResponseCode.TRANSACTION_WAS_EXECUTED.code()); context.setMessage(MgcpResponseCode.TRANSACTION_WAS_EXECUTED.message()); } catch (RuntimeException | MgcpConnectionException e) { log.error("Unexpected error occurred during tx=" + this.transactionId + " execution. Reason: " + e.getMessage() + ". Rolling back."); rollback(context); context.setCode(MgcpResponseCode.PROTOCOL_ERROR.code()); context.setMessage(MgcpResponseCode.PROTOCOL_ERROR.message()); } catch (MgcpCommandException e) { log.error("Protocol error occurred during tx=" + this.transactionId + " execution. Reason: " + e.getMessage()); context.setCode(e.getCode()); context.setMessage(e.getMessage()); } return respond(context); } }