DataManager.java revision 7c478bd95313f5f23a4c958a745db2134aa03244
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License, Version 1.0 only
* (the "License"). You may not use this file except in compliance
* with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* or http://www.opensolaris.org/os/licensing.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* ident "%Z%%M% %I% %E% SMI"
*
* Copyright (c) 1998-2001 by Sun Microsystems, Inc.
* All rights reserved.
*/
package com.sun.dhcpmgr.client;
import java.util.Arrays;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.text.MessageFormat;
import javax.swing.*;
import com.sun.dhcpmgr.bridge.*;
import com.sun.dhcpmgr.data.*;
import com.sun.dhcpmgr.server.*;
/**
* DataManager implements a central point of contact between the client and the
* server components; the client obtains all server object references through
* this class which allows us to cache information as much as possible,
* improving users' perception of the performance of the tool.
*/
public class DataManager {
private DhcpMgr server;
private DhcpNetMgr netMgr;
private DhcptabMgr dhcptabMgr;
private DhcpServiceMgr dhcpServiceMgr;
private Network [] networks;
private DhcpClientRecord [] clients;
private String clientNet;
private Macro [] macros;
private Option [] options;
private String serverName;
private String shortServerName;
private InetAddress serverAddress;
private static DataManager mgr = null;
private DataManager() {
reset();
}
public synchronized void reset() {
// Clear the data references; used by the applet to re-initialize
server = new DhcpMgrImpl();
netMgr = null;
dhcptabMgr = null;
dhcpServiceMgr = null;
/*
* The arrays aren't nulled so that we can use them as the lock objects
* in the synchronized blocks below
*/
networks = new Network[0];
clients = new DhcpClientRecord[0];
clientNet = null;
macros = new Macro[0];
options = new Option[0];
try {
serverAddress = InetAddress.getLocalHost();
setServerName(serverAddress.getHostName());
} catch (UnknownHostException e) {
serverName = shortServerName = "";
}
try {
StandardOptions.setAllOptions(
getDhcpServiceMgr().getInittabOptions(
Option.ctxts[Option.STANDARD].getCode()));
} catch (Throwable e) {
MessageFormat form = new MessageFormat(
ResourceStrings.getString("stdopts_init_error"));
Object [] args = new Object[1];
if (e instanceof BridgeException) {
args[0] = e.getMessage();
} else {
args[0] = e.toString();
}
JOptionPane.showMessageDialog(null,
form.format(args),
ResourceStrings.getString("init_error"),
JOptionPane.ERROR_MESSAGE);
}
}
private void setServerName(String name) {
serverName = name;
int i = serverName.indexOf('.');
if (i == -1) {
shortServerName = serverName;
} else {
shortServerName = serverName.substring(0, i);
}
}
/*
* Threading note: the following methods are all synchronized on the
* class so that server references and names are always set & retrieved
* in a consistent state.
*/
public synchronized static DataManager get() {
if (mgr == null) {
mgr = new DataManager();
}
return mgr;
}
public synchronized void setServer(String name) throws Exception {
setServerName(name);
serverAddress = null;
}
public synchronized DhcpMgr getServer() {
return server;
}
public synchronized String getServerName() {
return serverName;
}
public synchronized String getShortServerName() {
return shortServerName;
}
public synchronized InetAddress getServerAddress() {
return serverAddress;
}
public synchronized DhcpNetMgr getDhcpNetMgr() {
if (netMgr == null) {
netMgr = getServer().getNetMgr();
}
return netMgr;
}
public synchronized DhcptabMgr getDhcptabMgr() {
if (dhcptabMgr == null) {
dhcptabMgr = getServer().getDhcptabMgr();
}
return dhcptabMgr;
}
public synchronized DhcpServiceMgr getDhcpServiceMgr() {
if (dhcpServiceMgr == null) {
dhcpServiceMgr = getServer().getDhcpServiceMgr();
}
return dhcpServiceMgr;
}
/*
* End of class-synchronized methods. Remaining methods are synchronized
* at a data item level.
*/
public Network [] getNetworks(boolean forceUpdate) throws BridgeException {
synchronized (networks) {
if (forceUpdate || networks.length == 0) {
networks = getDhcpNetMgr().getNetworks();
if (networks == null) {
networks = new Network[0];
} else {
Arrays.sort(networks);
}
}
}
return networks;
}
public DhcpClientRecord [] getClients(String net, boolean forceUpdate)
throws BridgeException {
synchronized (clients) {
if (forceUpdate || clients.length == 0 || !net.equals(clientNet)) {
clients = getDhcpNetMgr().loadNetwork(net);
if (clients == null) {
clients = new DhcpClientRecord[0];
}
clientNet = net;
}
}
return clients;
}
public Macro [] getMacros(boolean forceUpdate) throws BridgeException {
synchronized (macros) {
if (forceUpdate || macros.length == 0) {
macros = getDhcptabMgr().getMacros();
if (macros == null) {
macros = new Macro[0];
}
}
}
return macros;
}
public Option [] getOptions(boolean forceUpdate) throws BridgeException {
synchronized (options) {
if (forceUpdate || options.length == 0) {
options = getDhcptabMgr().getOptions();
if (options == null) {
options = new Option[0];
}
/*
* Reload the site/vendor options portion of the global options
* table with the data we just loaded so that macro validation
* can be handled properly.
*/
OptionsTable.getTable().add(options);
}
}
return options;
}
}