@Override
public byte[] serialize() {
byte data[] = new byte[SIZE];
ByteBuffer bb = ByteBuffer.wrap(data);
bb.order(ByteOrder.BIG_ENDIAN);
bb.putLong(fViewerSessionId);
bb.putInt(fMajor);
bb.putInt(fMinor);
bb.putInt(fType.getCommand());
return data;
}
@Override
public ConnectionType getConnectionType() {
String type = null;
if (port_props.get(PORT_TYPE_PROP_KEY) == null) {
log.warning(
getName() + ": connection type is null: " + port_props.get(PORT_KEY).toString());
} else {
type = port_props.get(PORT_TYPE_PROP_KEY).toString();
}
return ConnectionType.valueOf(type);
}
public static void invoke(Configeration config, String paramStr) {
// Parameter given is as follows:
// Directive port-to-alias [alias-port(s)]
paramStr = paramStr.trim();
// Aquire data...
int portStrEnd = paramStr.indexOf(" ");
int port = parseInt(paramStr.substring(0, portStrEnd));
// Now get the aliaser ports.
String[] aliasList = paramStr.substring(portStrEnd + 1).trim().split(" ");
for (String aliasPort : aliasList) {
int alias = parseInt(aliasPort);
ConnectionType.addAlias(port, alias);
config.listenPorts.add(alias);
}
}
/**
* Creates a dialog where the user can specify the location of the database,including the type of
* network connection (if this is a networked client)and IP address and port number; or search and
* select the database on a local drive if this is a standalone client.
*
* @param parent Defines the Component that is to be the parent of this dialog box. For
* information on how this is used, see <code>JOptionPane</code>
* @param connectionMode Specifies the type of connection (standalone or networked)
* @see JOptionPane
*/
public DatabaseLocationDialog(Frame parent, ApplicationMode connectionMode) {
configOptions = (new ConfigOptions(connectionMode));
configOptions.getObservable().addObserver(this);
// load saved configuration
SavedConfiguration config = SavedConfiguration.getSavedConfiguration();
// the port and connection type are irrelevant in standalone mode
if (connectionMode == ApplicationMode.STANDALONE_CLIENT) {
validPort = true;
validCnx = true;
networkType = ConnectionType.DIRECT;
location = config.getParameter(SavedConfiguration.DATABASE_LOCATION);
} else {
// there may not be a network connectivity type defined and, if
// not, we do not set a default - force the user to make a choice
// the at least for the first time they run this.
String tmp = config.getParameter(SavedConfiguration.NETWORK_TYPE);
if (tmp != null) {
try {
networkType = ConnectionType.valueOf(tmp);
configOptions.setNetworkConnection(networkType);
validCnx = true;
} catch (IllegalArgumentException e) {
log.warning("Unknown connection type: " + networkType);
}
}
// there is always at least a default port number, so we don't have
// to validate this.
port = config.getParameter(SavedConfiguration.SERVER_PORT);
configOptions.setPortNumberText(port);
validPort = true;
location = config.getParameter(SavedConfiguration.SERVER_ADDRESS);
}
// there may not be a default database location, so we had better
// validate before using the returned value.
if (location != null) {
configOptions.setLocationFieldText(location);
validDb = true;
}
options =
new JOptionPane(configOptions, JOptionPane.QUESTION_MESSAGE, JOptionPane.OK_CANCEL_OPTION);
connectButton.setActionCommand(CONNECT);
connectButton.addActionListener(this);
boolean allValid = validDb && validPort && validCnx;
connectButton.setEnabled(allValid);
exitButton.setActionCommand(EXIT);
exitButton.addActionListener(this);
options.setOptions(new Object[] {connectButton, exitButton});
dialog = options.createDialog(parent, TITLE);
dialog.setDefaultCloseOperation(JDialog.DO_NOTHING_ON_CLOSE);
dialog.addWindowListener(this);
dialog.setVisible(true);
}
public void setConnectionType(String connectionType) {
this.connectionType = ConnectionType.toConnectionType(connectionType).toString();
}
@Override
public void setProperties(Map<String, Object> props) throws ConfigurationException {
super.setProperties(props);
if (props.get(MAX_INACTIVITY_TIME) != null) {
maxInactivityTime = (Long) props.get(MAX_INACTIVITY_TIME) * SECOND;
}
if (props.get(WHITE_CHAR_ACK_PROP_KEY) != null) {
white_char_ack = (Boolean) props.get(WHITE_CHAR_ACK_PROP_KEY);
}
if (props.get(XMPP_ACK_PROP_KEY) != null) {
xmpp_ack = (Boolean) props.get(XMPP_ACK_PROP_KEY);
}
if (props.get(NET_BUFFER_PROP_KEY) != null) {
net_buffer = (Integer) props.get(NET_BUFFER_PROP_KEY);
}
if (props.get(NET_BUFFER_LIMIT_PROP_KEY) != null) {
net_buffer_limit = (Integer) props.get(NET_BUFFER_LIMIT_PROP_KEY);
}
if (props.get(TRAFFIC_THROTTLING_PROP_KEY) != null) {
String[] tmp = ((String) props.get(TRAFFIC_THROTTLING_PROP_KEY)).split(",");
for (String tmp_s : tmp) {
String[] tmp_thr = tmp_s.split(":");
if (tmp_thr[0].equalsIgnoreCase("xmpp")) {
last_minute_packets_limit =
DataTypes.parseNum(tmp_thr[1], Long.class, LAST_MINUTE_PACKETS_LIMIT_PROP_VAL);
log.warning(getName() + " last_minute_packets_limit = " + last_minute_packets_limit);
total_packets_limit =
DataTypes.parseNum(tmp_thr[2], Long.class, TOTAL_PACKETS_LIMIT_PROP_VAL);
log.warning(getName() + " total_packets_limit = " + total_packets_limit);
if (tmp_thr[3].equalsIgnoreCase("disc")) {
xmppLimitAction = LIMIT_ACTION.DISCONNECT;
}
if (tmp_thr[3].equalsIgnoreCase("drop")) {
xmppLimitAction = LIMIT_ACTION.DROP_PACKETS;
}
}
if (tmp_thr[0].equalsIgnoreCase("bin")) {
last_minute_bin_limit =
DataTypes.parseNum(tmp_thr[1], Long.class, LAST_MINUTE_BIN_LIMIT_PROP_VAL);
log.warning(getName() + " last_minute_bin_limit = " + last_minute_bin_limit);
total_bin_limit = DataTypes.parseNum(tmp_thr[2], Long.class, TOTAL_BIN_LIMIT_PROP_VAL);
log.warning(getName() + " total_bin_limit = " + total_bin_limit);
}
}
}
if (props.get(ELEMENTS_NUMBER_LIMIT_PROP_KEY) != null) {
elements_number_limit = (int) props.get(ELEMENTS_NUMBER_LIMIT_PROP_KEY);
}
if (props.get(WATCHDOG_DELAY) != null) {
watchdogDelay = (long) props.get(WATCHDOG_DELAY);
}
if (props.get(WATCHDOG_TIMEOUT) != null) {
watchdogTimeout = (long) props.get(WATCHDOG_TIMEOUT);
}
if (props.get(WATCHDOG_PING_TYPE_KEY) != null) {
String value = String.valueOf(props.get(WATCHDOG_PING_TYPE_KEY));
watchdogPingType = WATCHDOG_PING_TYPE.valueOf(value.toUpperCase());
}
if (props.size() == 1) {
// If props.size() == 1, it means this is a single property update and
// ConnectionManager does not support it yet.
return;
}
if (isInitializationComplete()) {
// Do we really need to do this again?
// Looks like reconfiguration for the port is not working correctly anyway
// so for now we do not want to do it.
return;
}
releaseListeners();
int[] ports = (int[]) props.get(PORTS_PROP_KEY);
if (ports != null) {
for (int i = 0; i < ports.length; i++) {
Map<String, Object> port_props = new LinkedHashMap<String, Object>(20);
for (Map.Entry<String, Object> entry : props.entrySet()) {
if (entry.getKey().startsWith(PROP_KEY + ports[i])) {
int idx = entry.getKey().lastIndexOf('/');
String key = entry.getKey().substring(idx + 1);
log.log(
Level.CONFIG,
"Adding port property key: {0}={1}",
new Object[] {key, entry.getValue()});
port_props.put(key, entry.getValue());
} // end of if (entry.getKey().startsWith())
} // end of for ()
port_props.put(PORT_KEY, ports[i]);
if (port_props.containsKey(PORT_TYPE_PROP_KEY)
&& !(port_props.get(PORT_TYPE_PROP_KEY) instanceof ConnectionType)) {
Object val = port_props.get(PORT_TYPE_PROP_KEY);
port_props.put(PORT_TYPE_PROP_KEY, ConnectionType.valueOf(val.toString()));
}
if (port_props.containsKey(PORT_SOCKET_PROP_KEY)
&& !(port_props.get(PORT_SOCKET_PROP_KEY) instanceof SocketType)) {
Object val = port_props.get(PORT_SOCKET_PROP_KEY);
port_props.put(PORT_SOCKET_PROP_KEY, SocketType.valueOf(val.toString()));
}
addWaitingTask(port_props);
// reconnectService(port_props, startDelay);
} // end of for (int i = 0; i < ports.length; i++)
} // end of if (ports != null)
}
public void setConnectionType(String allowConnections) {
this.connectionType = ConnectionType.valueOf(allowConnections);
}
@Test
public void testCheckConnectionTemplate() throws Exception {
method =
class1.getDeclaredMethod(
"checkConnectionTemplate", new Class[] {AbstractConnection.class, Map.class});
method.setAccessible(true);
field = class1.getDeclaredField("getDefinitions");
field.setAccessible(true);
GetDefinitions getDefinitions = mock(GetDefinitions.class);
AbstractConnection connection = mock(AbstractConnection.class);
ConnectionDefinition connectionDefinition = mock(ConnectionDefinition.class);
ConnectionType connectionType = mock(ConnectionType.class);
PropertyDefinition propertyDefinition = mock(PropertyDefinition.class);
PropertyName propertyName = mock(PropertyName.class);
PropertyValues propertyValues = mock(PropertyValues.class);
StringValue stringValue = mock(StringValue.class);
PropertyDefinition.PropertyValueType type = PropertyDefinition.PropertyValueType.String;
TemplateParameter.ParameterValueType valueType = TemplateParameter.ParameterValueType.Int;
org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010
.connection.instance.Property
property =
mock(
org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object
.rev151010.connection.instance.Property.class);
List<
org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object.rev151010
.connection.instance.Property>
properties =
new ArrayList<
org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.object
.rev151010.connection.instance.Property>();
List<PropertyDefinition> propertyDefinitions = new ArrayList<PropertyDefinition>();
List<StringValue> stringValues = new ArrayList<StringValue>();
Map<ParameterName, TemplateParameter.ParameterValueType> parameterValueTypeMap =
new HashMap<ParameterName, TemplateParameter.ParameterValueType>();
Map<ConnectionType, ConnectionDefinition> connDefinitions =
new HashMap<ConnectionType, ConnectionDefinition>();
field.set(updateTemplateDefinition, getDefinitions);
propertyDefinitions.add(propertyDefinition);
properties.add(property);
stringValues.add(stringValue);
parameterValueTypeMap.put(new ParameterName("ParameterName"), valueType);
when(getDefinitions.getConnectionDefinition()).thenReturn(connDefinitions);
when(connection.getConnectionType()).thenReturn(connectionType);
when(connectionType.getValue()).thenReturn("test");
// test null
Assert.assertTrue(
method
.invoke(updateTemplateDefinition, connection, parameterValueTypeMap)
.equals(
"The connection type "
+ connection.getConnectionType().getValue()
+ " is not defined."));
// test not null
connDefinitions.put(connectionType, connectionDefinition);
when(connectionDefinition.getPropertyDefinition()).thenReturn(propertyDefinitions);
when(propertyDefinition.getPropertyName()).thenReturn(propertyName);
when(connection.getProperty()).thenReturn(null).thenReturn(properties);
Assert.assertTrue(
method.invoke(updateTemplateDefinition, connection, parameterValueTypeMap) == null);
when(property.getPropertyName()).thenReturn(mock(PropertyName.class)).thenReturn(propertyName);
when(propertyName.getValue()).thenReturn("test");
Assert.assertTrue(
method
.invoke(updateTemplateDefinition, connection, parameterValueTypeMap)
.equals(
"The property name " + property.getPropertyName().getValue() + " is not defined."));
Assert.assertTrue(type.getIntValue() == 0);
when(propertyDefinition.getPropertyValueType())
.thenReturn(PropertyDefinition.PropertyValueType.Int)
.thenReturn(type);
Assert.assertTrue(
method.invoke(updateTemplateDefinition, connection, parameterValueTypeMap) == null);
verify(propertyDefinition).getPropertyValueType();
when(property.getPropertyValues()).thenReturn(propertyValues);
when(propertyValues.getStringValue()).thenReturn(stringValues);
when(stringValue.getValue()).thenReturn(new String("ParameterName"));
Assert.assertTrue(parameterValueTypeMap.get(new ParameterName("ParameterName")) == valueType);
// System.out.println((String) method.invoke(updateTemplateDefinition, connection,
// parameterValueTypeMap));
// System.out.println("valuetype" + valueType.getIntValue());
Assert.assertTrue(
method
.invoke(updateTemplateDefinition, connection, parameterValueTypeMap)
.equals(
"The property " + property.getPropertyName().getValue() + " type is not right."));
verify(stringValue).getValue();
}
public void abortClientHandshake(String type) {
FMLLog.log(Level.INFO, "Aborting client handshake \"%s\"", type);
// FMLCommonHandler.instance().waitForPlayClient();
completeClientSideConnection(ConnectionType.valueOf(type));
}
