我正在寻找一种方法(重新)部署一个爆炸的包(意思是不震动，但在一个文件夹中)到一个运行的Apache Felix OSGi容器从Eclipse中，最好使用启动任务。
我发现了这个问题，它有一个接近的答案，但它取决于在Gogo shell中输入命令，这对于长期开发使用不方便。我希望使用Eclipse的启动任务机制来实现这一点，但是如果有同样快速和方便的替代方案，我也愿意使用。
现在我想，如果我可以从Eclipse启动任务中启动Gogo shell命令，那将是一个解决方案，但我也不知道如何做到这一点。我想我需要远程Shell包，对吧?
我开始考虑用Java写一个telnet客户端，它可以连接到远程Shell包，并以自动化的方式执行Gogo命令。我已经看到了一些例子，我可以根据自己的需要进行修改……然而，我从中得到了一种"重新发明轮子"的感觉。肯定有更好的办法吧?
一些背景来帮助你理解我在做什么:
我已经建立了一个Eclipse 'OSGiContainer'项目，它基本上包含了Apache Felix jar和我想要部署的第三方包(如Gogo shell)，类似于这里描述的项目设置。然后我创建了第二个"MyBundle"项目，它包含了我的bundle。我想通过启动OSGiContainer项目来启动OSGi容器，然后在我的bundle上进行开发，并通过在OSGiContainer中启动MyBundle项目来测试我的更改，我只是想在开发期间一直运行OSGiContainer。
项目布局:- OSGiContainer
- bin(包含felix jar)
- bundle(第三方bundle)
- conf (Felix的配置文件)属性文件)
- MyBundle
- src
- 目标
然后我可以通过在Gogo shell上调用这些命令来将我的bundle部署到OSGi容器:
install reference:file:../MyBundle/target/classes
start <bundleId>
stop <bundleId>
uninstall <bundleId>
install reference:file:../MyBundle/target/classes
start <bundleId>
你可以想象每次在shell上调用4个命令并不是那么有趣…所以，即使你能给我一种方法，把它归结为更少的命令来输入，这已经是一个很大的改进了。
我黑了一下，想出了下面的类。它是对telnet示例的改编，只做了一些小的修改，并提供了一个主要方法，其中包含卸载bundle，然后重新安装并启动它所需的命令。bundle的路径应该作为一个参数提供给程序，看起来像:
reference:file:../MyBundle/target/classes
我仍然非常欢迎这个问题的答案，因为我真的不喜欢这个解决方案。然而，我已经验证了这是有效的:
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintStream;
import java.net.SocketException;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.LinkedBlockingQueue;
import org.apache.commons.net.telnet.TelnetClient;
public class GogoDeployer {
static class Responder extends Thread {
private StringBuilder builder = new StringBuilder();
private final GogoDeployer checker;
private CountDownLatch latch;
private String waitFor = null;
private boolean isKeepRunning = true;
Responder(GogoDeployer checker) {
this.checker = checker;
}
boolean foundWaitFor(String waitFor) {
return builder.toString().contains(waitFor);
}
public synchronized String getAndClearBuffer() {
String result = builder.toString();
builder = new StringBuilder();
return result;
}
@Override
public void run() {
while (isKeepRunning) {
String s;
try {
s = checker.messageQueue.take();
} catch (InterruptedException e) {
break;
}
synchronized (Responder.class) {
builder.append(s);
}
if (waitFor != null && latch != null && foundWaitFor(waitFor)) {
latch.countDown();
}
}
System.out.println("Responder stopped.");
}
public String waitFor(String waitFor) {
synchronized (Responder.class) {
if (foundWaitFor(waitFor)) {
return getAndClearBuffer();
}
}
this.waitFor = waitFor;
latch = new CountDownLatch(1);
try {
latch.await();
} catch (InterruptedException e) {
e.printStackTrace();
return null;
}
String result = null;
synchronized (Responder.class) {
result = builder.toString();
builder = new StringBuilder();
}
return result;
}
}
static class TelnetReader extends Thread {
private boolean isKeepRunning = true;
private final GogoDeployer checker;
private final TelnetClient tc;
TelnetReader(GogoDeployer checker, TelnetClient tc) {
this.checker = checker;
this.tc = tc;
}
@Override
public void run() {
InputStream instr = tc.getInputStream();
try {
byte[] buff = new byte[1024];
int ret_read = 0;
do {
if (instr.available() > 0) {
ret_read = instr.read(buff);
}
if (ret_read > 0) {
checker.sendForResponse(new String(buff, 0, ret_read));
ret_read = 0;
}
} while (isKeepRunning && (ret_read >= 0));
} catch (Exception e) {
System.err.println("Exception while reading socket:" + e.getMessage());
}
try {
tc.disconnect();
checker.stop();
System.out.println("Disconnected.");
} catch (Exception e) {
System.err.println("Exception while closing telnet:" + e.getMessage());
}
}
}
private static final String prompt = "g!";
private static GogoDeployer client;
private String host;
private BlockingQueue<String> messageQueue = new LinkedBlockingQueue<String>();
private int port;
private TelnetReader reader;
private Responder responder;
private TelnetClient tc;
public GogoDeployer(String host, int port) {
this.host = host;
this.port = port;
}
public void stop() {
responder.isKeepRunning = false;
reader.isKeepRunning = false;
try {
Thread.sleep(10);
} catch (InterruptedException e) {
}
responder.interrupt();
reader.interrupt();
}
public void send(String command) {
PrintStream ps = new PrintStream(tc.getOutputStream());
ps.println(command);
ps.flush();
}
public void sendForResponse(String s) {
messageQueue.add(s);
}
public void connect() throws SocketException, IOException {
tc = new TelnetClient();
tc.connect(host, port);
reader = new TelnetReader(this, tc);
reader.start();
responder = new Responder(this);
responder.start();
}
public String waitFor(String s) {
return responder.waitFor(s);
}
private static String exec(String cmd) {
String result = "";
System.out.println(cmd);
client.send(cmd);
result = client.waitFor(prompt);
return result;
}
public static void main(String[] args) {
try {
String project = args[0];
client = new GogoDeployer("localhost", 6666);
client.connect();
System.out.println(client.waitFor(prompt));
System.out.println(exec("uninstall " + project));
String result = exec("install " + project);
System.out.println(result);
int start = result.indexOf(":");
int stop = result.indexOf(prompt);
String bundleId = result.substring(start + 1, stop).trim();
System.out.println(exec("start " + bundleId));
client.stop();
} catch (SocketException e) {
System.err.println("Unable to conect to Gogo remote shell: " + e.getMessage());
} catch (IOException e) {
System.err.println("Unable to conect to Gogo remote shell: " + e.getMessage());
}
}
}
当我满足了相同的要求(从目标/类中尽快部署bundle)时，我的第一个想法也是用一些shell功能扩展我的容器。然而，我的第二个想法是编写一个简单的bundle，它打开一个始终位于顶部的窗口，我可以简单地将Eclipse(或total commander或其他)中的任何项目拖放到该窗口中。代码然后检查被删除的文件夹是否有一个目标/类文件夹，如果有，将被部署。
源代码可从https://github.com/everit-org/osgi-richconsole
获得该依赖项可从maven-central获取。
依赖项为:
<dependency>
<groupId>org.everit.osgi.dev</groupId>
<artifactId>org.everit.osgi.dev.richconsole</artifactId>
<version>1.2.0</version>
</dependency>
您可以在开发时使用它，并在设置活动服务器时删除它。但是，如果容器在无头模式下运行，则不显示弹出窗口。
我把它叫做richconsole，因为我想在未来有更多的功能(不仅仅是部署):)