public LightDevice() throws InvalidDescriptionException {
super(new File(DESCRIPTION_FILE_NAME));
setSSDPBindAddress(HostInterface.getInetAddress(HostInterface.IPV4_BITMASK, null));
setHTTPBindAddress(HostInterface.getInetAddress(HostInterface.IPV4_BITMASK, null));
Action getPowerAction = getAction("GetPower");
getPowerAction.setActionListener(this);
Action setPowerAction = getAction("SetPower");
setPowerAction.setActionListener(this);
ServiceList serviceList = getServiceList();
Service service = serviceList.getService(0);
service.setQueryListener(this);
powerVar = getStateVariable("Power");
Argument powerArg = getPowerAction.getArgument("Power");
StateVariable powerState = powerArg.getRelatedStateVariable();
AllowedValueList allowList = powerState.getAllowedValueList();
for (int n = 0; n < allowList.size(); n++)
System.out.println("[" + n + "] = " + allowList.getAllowedValue(n));
AllowedValueRange allowRange = powerState.getAllowedValueRange();
System.out.println("maximum = " + allowRange.getMaximum());
System.out.println("minimum = " + allowRange.getMinimum());
System.out.println("step = " + allowRange.getStep());
}
public void update(UpdateMemo memo) throws Exception {
ArtifactData target = put(memo.best.urls.iterator().next());
memo.current.version = new Version(memo.best.version);
target.sync();
memo.current.sha = target.sha;
// memo.current.dependencies = target.dependencies;
// memo.current.dependencies.add((new File(repoDir,
// Hex.toHexString(target.sha))).getCanonicalPath());
// memo.current.runbundles = target.runbundles;
// memo.current.description = target.description;
memo.current.time = target.time;
if (memo.current instanceof ServiceData) {
Service service = getService((ServiceData) memo.current);
service.remove();
createService((ServiceData) memo.current);
IO.delete(new File(IO.getFile(serviceDir, memo.current.name), "data"));
storeData(new File(IO.getFile(serviceDir, memo.current.name), "data"), memo.current);
} else {
platform.deleteCommand(memo.current);
createCommand(memo.current, false);
IO.delete(IO.getFile(commandDir, memo.current.name));
storeData(IO.getFile(commandDir, memo.current.name), memo.current);
}
}
/**
* This is called when JPM runs in the background to start jobs
*
* @throws Exception
*/
public void daemon() throws Exception {
Runtime.getRuntime()
.addShutdownHook(
new Thread("Daemon shutdown") {
public void run() {
for (Service service : startedByDaemon) {
try {
reporter.error("Stopping " + service);
service.stop();
reporter.error("Stopped " + service);
} catch (Exception e) {
// Ignore
}
}
}
});
List<ServiceData> services = getServices();
Map<String, ServiceData> map = new HashMap<String, ServiceData>();
for (ServiceData d : services) {
map.put(d.name, d);
}
List<ServiceData> start = new ArrayList<ServiceData>();
Set<ServiceData> set = new HashSet<ServiceData>();
for (ServiceData sd : services) {
checkStartup(map, start, sd, set);
}
if (start.isEmpty()) reporter.warning("No services to start");
for (ServiceData sd : start) {
try {
Service service = getService(sd.name);
reporter.trace("Starting " + service);
String result = service.start();
if (result != null) reporter.error("Started error " + result);
else startedByDaemon.add(service);
reporter.trace("Started " + service);
} catch (Exception e) {
reporter.error("Cannot start daemon %s, due to %s", sd.name, e);
}
}
while (true) {
for (Service sd : startedByDaemon) {
try {
if (!sd.isRunning()) {
reporter.error("Starting due to failure " + sd);
String result = sd.start();
if (result != null) reporter.error("Started error " + result);
}
} catch (Exception e) {
reporter.error("Cannot start daemon %s, due to %s", sd, e);
}
}
Thread.sleep(10000);
}
}
public EntityImpl() throws Exception {
factory = Outside.service(this, "gus.io.printstream.factory.multi.hist");
p1 = (PrintStream) factory.g();
((P) p1).p(System.err);
System.setErr(p1);
}
/** Loads internal services */
private void loadInternalServices() {
try {
Iterator services;
String servicename;
String baseURL = System.getProperty("user.dir") + "/" + APPLICATIONS_DIRECTORY;
LucaneClassLoader loader = LucaneClassLoader.getInstance();
services = store.getServiceStore().getAllServices();
while (services.hasNext()) {
ServiceConcept service = (ServiceConcept) services.next();
servicename = service.getName();
try {
loader.addUrl(new URL("jar:file:///" + baseURL + servicename + ".jar!/"));
String className =
(new JarFile(baseURL + servicename + ".jar"))
.getManifest()
.getMainAttributes()
.getValue("Service-Class");
if (className == null) continue;
Service serv = (Service) Class.forName(className, true, loader).newInstance();
this.services.add(serv);
serv.init(this);
if (!service.isInstalled()) {
serv.install();
service.setInstalled();
store.getServiceStore().updateService(service);
}
Logging.getLogger().info("Service '" + servicename + "' loaded.");
this.connections.add(
new ConnectInfo(servicename, serverIp, serverIp, port, "nokey", "service"));
} catch (Exception e) {
Logging.getLogger().warning("Unable to load service '" + servicename);
}
}
} catch (Exception e) {
Logging.getLogger().warning("Unable to load internal services : " + e);
e.printStackTrace();
}
}
private String listFiles(final File cache, List<File> toDelete) throws Exception {
boolean stopServices = false;
if (toDelete == null) {
toDelete = new ArrayList<File>();
} else {
stopServices = true;
}
int count = 0;
Formatter f = new Formatter();
f.format(" - Cache:%n * %s%n", cache.getCanonicalPath());
f.format(" - Commands:%n");
for (CommandData cdata : getCommands(new File(cache, COMMANDS))) {
f.format(" * %s \t0 handle for \"%s\"%n", cdata.bin, cdata.name);
toDelete.add(new File(cdata.bin));
count++;
}
f.format(" - Services:%n");
for (ServiceData sdata : getServices(new File(cache, SERVICE))) {
if (sdata != null) {
f.format(" * %s \t0 service directory for \"%s\"%n", sdata.sdir, sdata.name);
toDelete.add(new File(sdata.sdir));
File initd = platform.getInitd(sdata);
if (initd != null && initd.exists()) {
f.format(" * %s \t0 init.d file for \"%s\"%n", initd.getCanonicalPath(), sdata.name);
toDelete.add(initd);
}
if (stopServices) {
Service s = getService(sdata);
try {
s.stop();
} catch (Exception e) {
}
}
count++;
}
}
f.format("%n");
String result = (count > 0) ? f.toString() : null;
f.close();
return result;
}
/**
* Write the xml for a {@link Service}.
*
* @param service
* @param contentHandler
* @throws SAXException
*/
protected static void generateXML(Service service, ContentHandler contentHandler)
throws SAXException {
final AttributesImpl ai = new AttributesImpl();
IOUtils.addAttribute(ai, "servicefactory", String.valueOf(service.isServicefactory()));
IOUtils.indent(contentHandler, 2);
contentHandler.startElement(
INNER_NAMESPACE_URI,
ComponentDescriptorIO.SERVICE,
ComponentDescriptorIO.SERVICE_QNAME,
ai);
if (service.getInterfaces() != null && service.getInterfaces().size() > 0) {
IOUtils.newline(contentHandler);
for (final Interface interf : service.getInterfaces()) {
generateXML(interf, contentHandler);
}
IOUtils.indent(contentHandler, 2);
}
contentHandler.endElement(
INNER_NAMESPACE_URI, ComponentDescriptorIO.SERVICE, ComponentDescriptorIO.SERVICE_QNAME);
IOUtils.newline(contentHandler);
}
/**
* Reads messages from the network. A message is either a command for the server or for an
* internal Service.
*
* @param sock the Socket
*/
private void getMessage(Socket sock) {
int i;
boolean alreadyConnected;
boolean isAuthentication;
Message message;
byte[] signature;
String cmd;
String cmdData;
StringTokenizer stk;
ObjectConnection oc = null;
try {
/* streams initialization */
oc = new ObjectConnection(sock);
message = (Message) oc.read();
signature = (byte[]) oc.read();
} catch (Exception ex) {
ex.printStackTrace();
Logging.getLogger().warning("#Err > Unable to read message.");
return;
}
// check wether a user is known or not
alreadyConnected = isAlreadyKnown(message.getSender());
// check if command is authentication
isAuthentication =
message.getApplication().equals("Server")
&& ((String) message.getData()).startsWith("AUTH");
// signature check
if (alreadyConnected && !isAuthentication) {
boolean sigok = false;
try {
ConnectInfo ci = message.getSender();
if (ci.verifier == null) ci = this.getCompleteConnectInfo(ci);
sigok = ci.verifier.verify(message, signature);
} catch (Exception e) {
e.printStackTrace();
}
if (!sigok) {
try {
oc.write("FAILED bad signature");
} catch (Exception e) {
}
Logging.getLogger().warning("#Err > bad signature: " + message.getSender());
return;
}
}
if (message.getApplication().equals("Server")) {
cmd = null;
try {
stk = new StringTokenizer((String) message.getData());
cmd = stk.nextToken();
cmdData = stk.nextToken("\0").substring(1);
} catch (Exception ex) {
if (cmd == null) cmd = "";
cmdData = "";
}
/* if the user asks for authentication, we try to do it and exits this method */
if (cmd.equals("AUTH")) {
try {
oc.write("OK");
} catch (Exception e) {
e.printStackTrace();
}
authentification(oc, message, cmdData);
} else if (!alreadyConnected) {
Logging.getLogger().info("Access denied to " + message.getSender());
try {
oc.write("FAILED No Connection");
} catch (Exception e) {
}
} else {
internalCommand(oc, message, cmd, cmdData);
}
} else if (!alreadyConnected) {
Logging.getLogger().info("Access denied to " + message.getSender());
try {
oc.write("FAILED No Connection");
} catch (Exception e) {
}
} else {
Service s;
/* seek the destination service */
boolean serviceFound = false;
for (i = 0; i < this.services.size(); i++) {
s = (Service) services.get(i);
if (s.getName().equalsIgnoreCase(message.getApplication())) {
serviceFound = true;
UserConcept user = null;
ServiceConcept service = null;
try {
user = store.getUserStore().getUser(message.getSender().getName());
service = store.getServiceStore().getService(message.getReceiver().getName());
} catch (Exception e) {
}
/* tests serviceManager for permissions */
boolean isAutorizedService = false;
try {
isAutorizedService = store.getServiceStore().isAuthorizedService(user, service);
} catch (Exception e) {
}
if (!isAutorizedService) {
Logging.getLogger()
.info(
"#Err > "
+ message.getSender()
+ " : Service denied to "
+ message.getReceiver().getName());
try {
oc.write("FAILED You don't have acces to this service");
} catch (Exception e) {
}
} else {
try {
oc.write("OK");
} catch (Exception e) {
}
serviceFound = true;
s.process(oc, message);
}
break;
}
}
if (!serviceFound) {
try {
oc.write("FAILED unknown");
} catch (Exception e) {
}
Logging.getLogger()
.warning("#Err > Service " + message.getReceiver().getName() + " unknown");
}
}
oc.close();
}