src/be/nikiroo/fanfix/library/WebLibrary.java

   1 package be.nikiroo.fanfix.library;
   2
   3 import java.io.File;
   4 import java.io.IOException;
   5 import java.io.InputStream;
   6 import java.net.URL;
   7 import java.util.ArrayList;
   8 import java.util.HashMap;
   9 import java.util.List;
  10 import java.util.Map;
  11
  12 import org.json.JSONArray;
  13 import org.json.JSONObject;
  14
  15 import be.nikiroo.fanfix.Instance;
  16 import be.nikiroo.fanfix.data.Chapter;
  17 import be.nikiroo.fanfix.data.JsonIO;
  18 import be.nikiroo.fanfix.data.MetaData;
  19 import be.nikiroo.fanfix.data.Paragraph;
  20 import be.nikiroo.fanfix.data.Paragraph.ParagraphType;
  21 import be.nikiroo.fanfix.data.Story;
  22 import be.nikiroo.utils.IOUtils;
  23 import be.nikiroo.utils.Image;
  24 import be.nikiroo.utils.Progress;
  25 import be.nikiroo.utils.Version;
  26
  27 /**
  28  * This {@link BasicLibrary} will access a remote server to list the available
  29  * stories, and download the ones you try to load to the local directory
  30  * specified in the configuration.
  31  * <p>
  32  * This remote library uses http:// or https://.
  33  *
  34  * @author niki
  35  */
  36 public class WebLibrary extends BasicLibrary {
  37         private String host;
  38         private int port;
  39         private final String key;
  40         private final String subkey;
  41
  42         // informative only (server will make the actual checks)
  43         private boolean rw;
  44
  45         /**
  46          * Create a {@link RemoteLibrary} linked to the given server.
  47          * <p>
  48          * Note that the key is structured:
  49          * <tt><b><i>xxx</i></b>(|<b><i>yyy</i></b>|<b>wl</b>)(|<b>rw</b>)</tt>
  50          * <p>
  51          * Note that anything before the first pipe (<tt>|</tt>) character is
  52          * considered to be the encryption key, anything after that character is
  53          * called the subkey (including the other pipe characters and flags!).
  54          * <p>
  55          * This is important because the subkey (including the pipe characters and
  56          * flags) must be present as-is in the server configuration file to be
  57          * allowed.
  58          * <ul>
  59          * <li><b><i>xxx</i></b>: the encryption key used to communicate with the
  60          * server</li>
  61          * <li><b><i>yyy</i></b>: the secondary key</li>
  62          * <li><b>rw</b>: flag to allow read and write access if it is not the
  63          * default on this server</li>
  64          * <li><b>wl</b>: flag to allow access to all the stories (bypassing the
  65          * whitelist if it exists)</li>
  66          * </ul>
  67          * <p>
  68          * Some examples:
  69          * <ul>
  70          * <li><b>my_key</b>: normal connection, will take the default server
  71          * options</li>
  72          * <li><b>my_key|agzyzz|wl</b>: will ask to bypass the white list (if it
  73          * exists)</li>
  74          * <li><b>my_key|agzyzz|rw</b>: will ask read-write access (if the default
  75          * is read-only)</li>
  76          * <li><b>my_key|agzyzz|wl|rw</b>: will ask both read-write access and white
  77          * list bypass</li>
  78          * </ul>
  79          *
  80          * @param key
  81          *            the key that will allow us to exchange information with the
  82          *            server
  83          * @param host
  84          *            the host to contact or NULL for localhost
  85          * @param port
  86          *            the port to contact it on
  87          */
  88         public WebLibrary(String key, String host, int port) {
  89                 int index = -1;
  90                 if (key != null) {
  91                         index = key.indexOf('|');
  92                 }
  93
  94                 if (index >= 0) {
  95                         this.key = key.substring(0, index);
  96                         this.subkey = key.substring(index + 1);
  97                 } else {
  98                         this.key = key;
  99                         this.subkey = "";
 100                 }
 101
 102                 this.rw = subkey.contains("|rw");
 103
 104                 this.host = host;
 105                 this.port = port;
 106
 107                 // TODO: not supported yet
 108                 this.rw = false;
 109         }
 110
 111         public Version getVersion() {
 112                 try {
 113                         InputStream in = download(WebLibraryUrls.VERSION_URL);
 114                         try {
 115                                 return new Version(IOUtils.readSmallStream(in));
 116                         } finally {
 117                                 in.close();
 118                         }
 119                 } catch (IOException e) {
 120                 }
 121
 122                 return null;
 123         }
 124
 125         @Override
 126         public Status getStatus() {
 127                 try {
 128                         download(WebLibraryUrls.INDEX_URL).close();
 129                 } catch (IOException e) {
 130                         try {
 131                                 download(WebLibraryUrls.VERSION_URL).close();
 132                                 return Status.UNAUTHORIZED;
 133                         } catch (IOException ioe) {
 134                                 return Status.UNAVAILABLE;
 135                         }
 136                 }
 137
 138                 return rw ? Status.READ_WRITE : Status.READ_ONLY;
 139         }
 140
 141         @Override
 142         public String getLibraryName() {
 143                 return (rw ? "[READ-ONLY] " : "") + host + ":" + port;
 144         }
 145
 146         @Override
 147         public Image getCover(String luid) throws IOException {
 148                 InputStream in = download(WebLibraryUrls.getStoryUrlCover(luid));
 149                 try {
 150                         return new Image(in);
 151                 } finally {
 152                         in.close();
 153                 }
 154         }
 155
 156         @Override
 157         public Image getCustomSourceCover(final String source) throws IOException {
 158                 // TODO maybe global system in BasicLib ?
 159                 return null;
 160         }
 161
 162         @Override
 163         public Image getCustomAuthorCover(final String author) throws IOException {
 164                 // TODO maybe global system in BasicLib ?
 165                 return null;
 166         }
 167
 168         @Override
 169         public void setSourceCover(String source, String luid) throws IOException {
 170                 // TODO Auto-generated method stub
 171                 throw new IOException("Not implemented yet");
 172         }
 173
 174         @Override
 175         public void setAuthorCover(String author, String luid) throws IOException {
 176                 // TODO Auto-generated method stub
 177                 throw new IOException("Not implemented yet");
 178         }
 179
 180         @Override
 181         public synchronized Story getStory(final String luid, Progress pg)
 182                         throws IOException {
 183
 184                 // TODO: pg
 185
 186                 Story story;
 187                 InputStream in = download(WebLibraryUrls.getStoryUrlJson(luid));
 188                 try {
 189                         JSONObject json = new JSONObject(IOUtils.readSmallStream(in));
 190                         story = JsonIO.toStory(json);
 191                 } finally {
 192                         in.close();
 193                 }
 194
 195                 story.getMeta().setCover(getCover(luid));
 196                 int chapNum = 1;
 197                 for (Chapter chap : story) {
 198                         int number = 1;
 199                         for (Paragraph para : chap) {
 200                                 if (para.getType() == ParagraphType.IMAGE) {
 201                                         InputStream subin = download(
 202                                                         WebLibraryUrls.getStoryUrl(luid, chapNum, number));
 203                                         try {
 204                                                 para.setContentImage(new Image(subin));
 205                                         } finally {
 206                                                 subin.close();
 207                                         }
 208                                 }
 209
 210                                 number++;
 211                         }
 212
 213                         chapNum++;
 214                 }
 215
 216                 return story;
 217         }
 218
 219         @Override
 220         protected List<MetaData> getMetas(Progress pg) throws IOException {
 221                 List<MetaData> metas = new ArrayList<MetaData>();
 222                 InputStream in = download(WebLibraryUrls.LIST_URL_METADATA);
 223                 JSONArray jsonArr = new JSONArray(IOUtils.readSmallStream(in));
 224                 for (int i = 0; i < jsonArr.length(); i++) {
 225                         JSONObject json = jsonArr.getJSONObject(i);
 226                         metas.add(JsonIO.toMetaData(json));
 227                 }
 228
 229                 return metas;
 230         }
 231
 232         @Override
 233         // Could work (more slowly) without it
 234         public MetaData imprt(final URL url, Progress pg) throws IOException {
 235                 if (true)
 236                         throw new IOException("Not implemented yet");
 237
 238                 // Import the file locally if it is actually a file
 239
 240                 if (url == null || url.getProtocol().equalsIgnoreCase("file")) {
 241                         return super.imprt(url, pg);
 242                 }
 243
 244                 // Import it remotely if it is an URL
 245
 246                 // TODO
 247                 return super.imprt(url, pg);
 248         }
 249
 250         @Override
 251         // Could work (more slowly) without it
 252         protected synchronized void changeSTA(final String luid,
 253                         final String newSource, final String newTitle,
 254                         final String newAuthor, Progress pg) throws IOException {
 255                 // TODO
 256                 super.changeSTA(luid, newSource, newTitle, newAuthor, pg);
 257         }
 258
 259         @Override
 260         protected void updateInfo(MetaData meta) {
 261                 // Will be taken care of directly server side
 262         }
 263
 264         @Override
 265         protected void invalidateInfo(String luid) {
 266                 // Will be taken care of directly server side
 267         }
 268
 269         // The following methods are only used by Save and Delete in BasicLibrary:
 270
 271         @Override
 272         protected int getNextId() {
 273                 throw new java.lang.InternalError("Should not have been called");
 274         }
 275
 276         @Override
 277         protected void doDelete(String luid) throws IOException {
 278                 throw new java.lang.InternalError("Should not have been called");
 279         }
 280
 281         @Override
 282         protected Story doSave(Story story, Progress pg) throws IOException {
 283                 throw new java.lang.InternalError("Should not have been called");
 284         }
 285
 286         //
 287
 288         @Override
 289         public File getFile(final String luid, Progress pg) {
 290                 throw new java.lang.InternalError(
 291                                 "Operation not supportorted on remote Libraries");
 292         }
 293
 294         // starts with "/", never NULL
 295         private InputStream download(String path) throws IOException {
 296                 URL url = new URL(host + ":" + port + path);
 297
 298                 Map<String, String> post = new HashMap<String, String>();
 299                 post.put("login", subkey);
 300                 post.put("password", key);
 301
 302                 return Instance.getInstance().getCache().openNoCache(url, null, post,
 303                                 null, null);
 304         }
 305 }