package jalview.io;
import jalview.exceptions.NoFileSelectedException;
-import jalview.ftp.FtpClient;
import jalview.gui.AlignViewport;
import jalview.gui.AlignmentPanel;
import jalview.gui.FeatureRenderer;
+import jalview.json.binding.v1.BioJSReleasePojo;
+import jalview.json.binding.v1.BioJSRepositoryPojo;
import jalview.util.MessageManager;
+import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.File;
import java.io.IOException;
+import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.URISyntaxException;
import java.util.Objects;
import java.util.TreeMap;
-import org.apache.commons.net.ftp.FTP;
-import org.apache.commons.net.ftp.FTPClient;
-import org.apache.commons.net.ftp.FTPFile;
-
public class BioJsHTMLOutput
{
public static final String BJS_TEMPLATES_LOCAL_DIRECTORY = jalview.bin.Cache
.getDefault("biojs_template_directory", "/biojs_templates/");
- public static final String BJS_FTP_USER = jalview.bin.Cache.getDefault(
- "biojs_ftp_user", "test");
-
- public static final String BJS_FTP_PWD = jalview.bin.Cache.getDefault(
- "biojs_ftp_pwd", "test");
-
- public static final String BJS_FTP_PORT = jalview.bin.Cache.getDefault(
- "biojs_ftp_port", "22");
-
- public static final String BJS_FTP_SERVER = jalview.bin.Cache.getDefault(
- "biojs_ftp_server", "localhost");
+ public static final String BJS_TEMPLATE_GIT_REPO = jalview.bin.Cache
+ .getDefault(
+ "biojs_template_git_repo",
+ "https://raw.githubusercontent.com/tcofoegbu/bjs-template/master/package.json");;
public BioJsHTMLOutput(AlignmentPanel ap,
FeatureRenderer fr1)
{
-
if (ap != null)
{
-
this.av = ap.av;
av.setFeatureRenderer(new FeatureRenderer(ap));
}
-
}
public void exportJalviewAlignmentAsBioJsHtmlFile()
return sb.toString();
}
- public TreeMap<String, File> updateBioJSVersionsInfo(String dirName)
+ public void refreshBioJSVersionsInfo(String dirName)
throws URISyntaxException
{
URL url = getClass().getResource(dirName);
{
setCurrentBJSTemplateFile(versionFileMap.lastEntry().getValue());
}
- return versionFileMap;
+ setBioJsMSAVersions(versionFileMap);
}
public void updateBioJS()
{
- TreeMap<String, File> versionLists = null;
try
{
- // downlaodNewBioJsTemplates(BJS_TEMPLATES_LOCAL_DIRECTORY);
- versionLists = updateBioJSVersionsInfo(BJS_TEMPLATES_LOCAL_DIRECTORY);
- setBioJsMSAVersions(versionLists);
+ String gitRepoPkgJson = getURLContentAsString(BJS_TEMPLATE_GIT_REPO);
+ BioJSRepositoryPojo release = new BioJSRepositoryPojo(gitRepoPkgJson);
+ syncUpdates(BJS_TEMPLATES_LOCAL_DIRECTORY, release);
+ refreshBioJSVersionsInfo(BJS_TEMPLATES_LOCAL_DIRECTORY);
} catch (URISyntaxException e)
{
e.printStackTrace();
}
}
- public void downlaodNewBioJsTemplates(String localDirectory)
+
+ public void syncUpdates(String localDir, BioJSRepositoryPojo repo)
+ throws URISyntaxException
{
- FTPClient client = FtpClient.getFtpClient(BJS_FTP_SERVER);
- if (FtpClient.authenticateUser(client, BJS_FTP_USER, BJS_FTP_PWD))
+ for (BioJSReleasePojo bjsRelease : repo.getReleases())
{
- client.enterLocalPassiveMode();
- try
+ String releaseUrl = bjsRelease.getUrl();
+ String releaseVersion = bjsRelease.getVersion();
+ String releaseFile = "BioJsMSA_" + releaseVersion + ".txt";
+ if (releaseVersion.equals(repo.getLatestReleaseVersion()))
{
- client.setFileType(FTP.BINARY_FILE_TYPE);
- for (FTPFile fFile : client.listFiles())
+ releaseFile = "Latest_BioJsMSA_" + releaseVersion + ".txt";
+ }
+ File file = null;
+ URL url = getClass().getResource(
+ BJS_TEMPLATES_LOCAL_DIRECTORY + releaseFile);
+ if (url == null)
+ {
+ String path = getClass().getResource(BJS_TEMPLATES_LOCAL_DIRECTORY)
+ .getPath();
+ System.out.println("------> " + path);
+ file = new File(path + releaseFile);
+ }
+ else
+ {
+ file = new File(url.toURI());
+ }
+
+ if (!file.exists())
+ {
+ PrintWriter out = null;
+ try
+ {
+ out = new java.io.PrintWriter(new java.io.FileWriter(file));
+ out.print(getURLContentAsString(releaseUrl));
+ } catch (IOException e)
+ {
+ e.printStackTrace();
+ } finally
{
- String localFileName = BJS_TEMPLATES_LOCAL_DIRECTORY
- + fFile.getName();
- String remoteFileName = fFile.getName();
- FtpClient.downloadFile(client, remoteFileName, localFileName);
+ if (out != null)
+ {
+ out.flush();
+ out.close();
+ }
}
- } catch (IOException e)
- {
- e.printStackTrace();
}
}
+
}
- // public static void main(String[] args) throws IOException
- // {
- // Document doc = Jsoup.connect("http://howto.unixdev.net").get();
- // for (Element file : doc.select("td.right td a"))
- // {
- // System.out.println(file.attr("href"));
- // }
- // }
+ public static String getURLContentAsString(String url)
+ throws OutOfMemoryError
+ {
+ StringBuilder responseStrBuilder = null;
+ InputStream is = null;
+ try
+ {
+ URL resourceUrl = new URL(url);
+ is = new BufferedInputStream(resourceUrl.openStream());
+ BufferedReader br = new BufferedReader(new InputStreamReader(is));
+ responseStrBuilder = new StringBuilder();
+ String lineContent;
+
+ while ((lineContent = br.readLine()) != null)
+ {
+ responseStrBuilder.append(lineContent).append("\n");
+ }
+ } catch (OutOfMemoryError er)
+ {
+ er.printStackTrace();
+ } catch (Exception ex)
+ {
+ ex.printStackTrace();
+ } finally
+ {
+ if (is != null)
+ {
+ try
+ {
+ is.close();
+ } catch (IOException e)
+ {
+ e.printStackTrace();
+ }
+ }
+ }
+ return responseStrBuilder == null ? null : responseStrBuilder
+ .toString();
+ }
public static File getCurrentBJSTemplateFile()
{
BioJsHTMLOutput.bioJsMSAVersions = bioJsMSAVersions;
}
-
}
--- /dev/null
+package jalview.json.binding.v1;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Iterator;
+
+import org.json.simple.JSONArray;
+import org.json.simple.JSONObject;
+import org.json.simple.parser.JSONParser;
+import org.json.simple.parser.ParseException;
+
+public class BioJSRepositoryPojo
+{
+
+ private String description;
+
+ private String latestReleaseVersion;
+
+ private Collection<BioJSReleasePojo> releases = new ArrayList<BioJSReleasePojo>();
+
+ public BioJSRepositoryPojo()
+ {
+ }
+
+ public BioJSRepositoryPojo(String jsonString)
+ {
+ try
+ {
+ parse(jsonString);
+ } catch (ParseException e)
+ {
+ e.printStackTrace();
+ }
+ }
+
+ @SuppressWarnings("unchecked")
+ private void parse(String jsonString) throws ParseException
+ {
+ JSONParser jsonParser = new JSONParser();
+ JSONObject JsonObj = (JSONObject) jsonParser.parse(jsonString);
+ this.description = (String) JsonObj.get("description");
+ this.latestReleaseVersion = (String) JsonObj
+ .get("latestReleaseVersion");
+
+ JSONArray repositoriesJsonArray = (JSONArray) JsonObj
+.get("realseases");
+ for (Iterator<JSONObject> repoIter = repositoriesJsonArray.iterator(); repoIter
+ .hasNext();)
+ {
+ JSONObject repoObj = repoIter.next();
+ BioJSReleasePojo repo = new BioJSReleasePojo();
+ repo.setType((String) repoObj.get("type"));
+ repo.setUrl((String) repoObj.get("url"));
+ repo.setVersion((String) repoObj.get("version"));
+ this.getReleases().add(repo);
+ }
+ }
+
+ public String getDescription()
+ {
+ return description;
+ }
+
+ public void setDescription(String description)
+ {
+ this.description = description;
+ }
+
+
+ public String getLatestReleaseVersion()
+ {
+ return latestReleaseVersion;
+ }
+
+ public void setLatestReleaseVersion(String latestReleaseVersion)
+ {
+ this.latestReleaseVersion = latestReleaseVersion;
+ }
+
+ public Collection<BioJSReleasePojo> getReleases()
+ {
+ return releases;
+ }
+
+ public void setReleases(Collection<BioJSReleasePojo> releases)
+ {
+ this.releases = releases;
+ }
+
+}
package jalview.io;
+import jalview.json.binding.v1.BioJSReleasePojo;
+import jalview.json.binding.v1.BioJSRepositoryPojo;
+
import java.io.File;
import java.io.IOException;
+import java.net.MalformedURLException;
import java.net.URISyntaxException;
+import java.net.URL;
+import java.net.URLConnection;
import java.util.TreeMap;
import org.junit.Assert;
BioJsHTMLOutput bjs = new BioJsHTMLOutput(null, null);
try
{
- bjs.updateBioJSVersionsInfo(null);
+ bjs.refreshBioJSVersionsInfo(null);
} catch (URISyntaxException e)
{
Assert.fail("Expception occured while testing!");
TreeMap<String, File> versions = null;
try
{
- versions = bjs
- .updateBioJSVersionsInfo(BioJsHTMLOutput.BJS_TEMPLATES_LOCAL_DIRECTORY);
+ bjs.refreshBioJSVersionsInfo(BioJsHTMLOutput.BJS_TEMPLATES_LOCAL_DIRECTORY);
+ versions = BioJsHTMLOutput.getBioJsMSAVersions();
} catch (URISyntaxException e)
{
Assert.fail("Expception occured while testing!");
BioJsHTMLOutput.getCurrentBJSTemplateFile());
}
+
+ @Test
+ public void testBioJsUpdate()
+ {
+ String url = BioJsHTMLOutput.BJS_TEMPLATE_GIT_REPO;
+ Assert.assertTrue("URL not reacable : " + url, urlIsReachable(url));
+ String response = BioJsHTMLOutput.getURLContentAsString(url);
+ Assert.assertNotNull("Null response read from url!", response);
+ BioJSRepositoryPojo repository = new BioJSRepositoryPojo(response);
+ System.out.println(">>> description : " + repository.getDescription());
+ System.out
+.println(">>> latest version : "
+ + repository.getLatestReleaseVersion());
+ System.out.println(">>> repo count : "
+ + repository.getReleases().size());
+ for (BioJSReleasePojo release : repository.getReleases())
+ {
+ System.out.println("repo type : " + release.getType());
+ System.out.println("url : " + release.getUrl());
+ System.out.println("release version : " + release.getVersion());
+ }
+ }
+
+ private static boolean urlIsReachable(String urlString)
+ {
+ try
+ {
+ final URL url = new URL(urlString);
+ final URLConnection conn = url.openConnection();
+ conn.connect();
+ return true;
+ } catch (MalformedURLException e)
+ {
+ throw new RuntimeException(e);
+ } catch (IOException e)
+ {
+ return false;
+ }
+ }
}
git://source.jalview.org / jalview.git / commitdiff