sdnr/wireless-transport/code-Carbon-SR1/apps/devicemanager/impl/src/main/java/org/opendaylight/mwtn/base/internalTypes/Resources.java

   1 package org.opendaylight.mwtn.base.internalTypes;
   2
   3
   4 import java.io.BufferedReader;
   5 import java.io.File;
   6 import java.io.FileFilter;
   7 import java.io.FileInputStream;
   8 import java.io.FileOutputStream;
   9 import java.io.IOException;
  10 import java.io.InputStream;
  11 import java.io.InputStreamReader;
  12 import java.io.OutputStream;
  13 import java.net.MalformedURLException;
  14 import java.net.URISyntaxException;
  15 import java.net.URL;
  16 import java.util.ArrayList;
  17 import java.util.Enumeration;
  18 import java.util.List;
  19
  20 import org.json.JSONException;
  21 import org.json.JSONObject;
  22 import org.osgi.framework.Bundle;
  23 import org.osgi.framework.FrameworkUtil;
  24 import org.slf4j.Logger;
  25 import org.slf4j.LoggerFactory;
  26
  27 public class Resources {
  28
  29         private static final Logger LOG = LoggerFactory.getLogger(Resources.class);
  30
  31
  32         private static URL getFileURL(String resFile)
  33         {
  34                 Bundle b = FrameworkUtil.getBundle(Resources.class);
  35                 URL u=null;
  36                 if(b==null)
  37                 {
  38                         LOG.warn("cannot load bundle resources");
  39                         try {
  40                                 u=new File("src/main/resources"+resFile).toURI().toURL();
  41                         } catch (MalformedURLException e) {
  42                                 LOG.warn(e.getMessage());
  43                         }
  44                 }
  45                 else
  46                         u= b.getEntry(resFile);
  47                 return u;
  48         }
  49
  50         private static File getFile(String resFile)
  51         {
  52                 Bundle b = FrameworkUtil.getBundle(Resources.class);
  53                 File f=null;
  54                 if(b==null)
  55                 {
  56                         LOG.warn("cannot load bundle resources");
  57                         f=new File("src/main/resources"+resFile);
  58                 } else
  59                         try {
  60                                 f=new File(b.getEntry(resFile).toURI());
  61                         } catch (URISyntaxException e) {
  62
  63                         }
  64                 return f;
  65         }
  66
  67         private static String readFile(final URL u) throws IOException
  68         {
  69                 return readFile(u.openStream());
  70         }
  71         private static String readFile(final File f) throws IOException
  72         {
  73                 return readFile(new FileInputStream(f));
  74         }
  75         private static String readFile(final InputStream s) throws IOException
  76         {
  77                 //read file
  78                 BufferedReader in = new BufferedReader(new InputStreamReader(s));
  79         StringBuilder sb=new StringBuilder();
  80                 String inputLine;
  81         while ((inputLine = in.readLine()) != null)
  82         {
  83                 sb.append(inputLine);
  84         }
  85             in.close();
  86             s.close();
  87             return sb.toString();
  88         }
  89
  90         public static String getFileContent(String resFile) throws IOException
  91         {
  92                 return readFile(getFileURL(resFile));
  93         }
  94         public static List<File> getFiles(String folder,final String filter,final boolean recursive)
  95         {
  96                 List<File> list=new ArrayList<File>();
  97                 FileFilter ff=new FileFilter() {
  98
  99                         @Override
 100                         public boolean accept(File pathname) {
 101                                 if(pathname.isFile())
 102                                         return pathname.getName().contains(filter);
 103                                 else
 104                                         return true;
 105                         }
 106                 };
 107                 File ffolder=getFile(folder);
 108                 if(ffolder!=null && ffolder.isDirectory())
 109                 {
 110                         File[] files=ffolder.listFiles(ff);
 111                         if(files!=null && files.length>0)
 112                         {
 113                                 for(File f:files)
 114                                 {
 115                                         if(f.isFile())
 116                                                 list.add(f);
 117                                         else if(f.isDirectory() && recursive)
 118                                         {
 119                                                 getFilesRecursive(f,ff,list);
 120                                         }
 121                                 }
 122                         }
 123                 }
 124                 return list;
 125         }
 126         public static List<URL> getFileURLs(String folder,final String filter,final boolean recursive) throws IOException
 127         {
 128                 Bundle b = FrameworkUtil.getBundle(Resources.class);
 129                 List<URL> list=new ArrayList<URL>();
 130                 if(b==null)
 131                 {
 132                         FileFilter ff=new FileFilter() {
 133
 134                                 @Override
 135                                 public boolean accept(File pathname) {
 136                                         if(pathname.isFile())
 137                                                 return pathname.getName().contains(filter);
 138                                         else
 139                                                 return true;
 140                                 }
 141                         };
 142                         File ffolder=getFile(folder);
 143                         if(ffolder!=null && ffolder.isDirectory())
 144                         {
 145                                 File[] files=ffolder.listFiles(ff);
 146                                 if(files!=null && files.length>0)
 147                                 {
 148                                         for(File f:files)
 149                                         {
 150                                                 if(f.isFile())
 151                                                         list.add(f.toURI().toURL());
 152                                                 else if(f.isDirectory() && recursive)
 153                                                 {
 154                                                         getFileURLsRecursive(f,ff,list);
 155                                                 }
 156                                         }
 157                                 }
 158                         }
 159                 }
 160                 else
 161                 {
 162                         getResourceURLsTreeRecurse(b,filter,b.getEntryPaths(folder),recursive,list);
 163                 }
 164                 return list;
 165         }
 166         private static void getFilesRecursive(File root, FileFilter ff, List<File> list) {
 167                 if(root!=null && root.isDirectory())
 168                 {
 169                         File[] files=root.listFiles(ff);
 170                         if(files!=null && files.length>0)
 171                         {
 172                                 for(File f:files)
 173                                 {
 174                                         if(f.isFile())
 175                                                 list.add(f);
 176                                         else if(f.isDirectory())
 177                                         {
 178                                                 getFilesRecursive(f,ff,list);
 179                                         }
 180                                 }
 181                         }
 182                 }
 183
 184         }
 185         private static void getFileURLsRecursive(File root, FileFilter ff, List<URL> list) throws MalformedURLException {
 186                 if(root!=null && root.isDirectory())
 187                 {
 188                         File[] files=root.listFiles(ff);
 189                         if(files!=null && files.length>0)
 190                         {
 191                                 for(File f:files)
 192                                 {
 193                                         if(f.isFile())
 194                                                 list.add(f.toURI().toURL());
 195                                         else if(f.isDirectory())
 196                                         {
 197                                                 getFileURLsRecursive(f,ff,list);
 198                                         }
 199                                 }
 200                         }
 201                 }
 202
 203         }
 204         private static void getResourceURLsTreeRecurse(Bundle b, String filter, Enumeration<String> resource,boolean recursive,List<URL> outp) throws IOException {
 205                 while (resource.hasMoreElements()) {
 206                         String name = resource.nextElement();
 207                         Enumeration<String> list = b.getEntryPaths(name);
 208                         if (list != null) {
 209                                 if(recursive)
 210                                         getResourceURLsTreeRecurse(b, filter, list,recursive,outp);
 211                         } else {
 212                                 //Read
 213                                 if(name.contains(filter))
 214                                 {
 215                                         LOG.debug("add "+name+ " to list");
 216                                         outp.add(b.getEntry(name));
 217                                 }
 218                                 else
 219                                         LOG.debug("filtered out "+name);
 220                         }
 221                 }
 222         }
 223         public static List<JSONObject> getJSONFiles(String folder,boolean recursive)
 224         {
 225                 List<URL> urls=null;
 226                 try {
 227                         urls = getFileURLs(folder,".json",recursive);
 228                 } catch (IOException e1) {
 229                         LOG.warn("failed to get urls from resfolder "+folder+" : "+e1.getMessage());
 230                 }
 231                 LOG.debug("found "+urls==null?"no":urls.size()+" files");
 232                 List<JSONObject> list=new ArrayList<JSONObject>();
 233                 if(urls!=null)
 234                 {
 235                         for (URL u: urls)
 236                         {
 237                                 LOG.debug("try to parse "+u.toString());
 238                                 try {
 239                                         JSONObject o=new JSONObject(readFile(u));
 240                                         list.add(o);
 241                                 } catch (JSONException | IOException e) {
 242                                         LOG.warn("problem reading/parsing file "+u+" :"+e.getMessage());
 243                                 }
 244                         }
 245                 }
 246                 return list;
 247         }
 248         public static JSONObject getJSONFile(String resFile) {
 249                 LOG.debug("loading json file "+resFile+" from res");
 250                 URL u=getFileURL(resFile);
 251                 if (u == null)
 252                 {
 253                         LOG.warn("cannot find resfile: "+resFile);
 254                         return null;
 255                 }
 256                 JSONObject o=null;
 257                 try
 258                 {
 259                         //parse to jsonobject
 260                     o=new JSONObject(readFile(u));
 261                 }
 262                 catch(Exception e)
 263                 {
 264                         LOG.warn("problem reading/parsing file: "+e.getMessage());
 265                 }
 266                 return o;
 267         }
 268
 269         public static boolean extractFileTo(String resFile, File oFile) {
 270         if(oFile==null)
 271                 return false;
 272         LOG.debug("try to copy "+resFile+" from res to "+oFile.getAbsolutePath());
 273         URL u=getFileURL(resFile);
 274                 if (u == null)
 275                 {
 276                         LOG.warn("cannot find resfile:"+resFile);
 277                         return false;
 278                 }
 279                 try {
 280                         InputStream in = u.openStream();
 281                         oFile.getParentFile().mkdirs();
 282                         OutputStream outStream;
 283                         outStream = new FileOutputStream(oFile);
 284                         int theInt;
 285                         while ((theInt = in.read()) >= 0) {
 286                                 outStream.write(theInt);
 287                         }
 288                         in.close();
 289                         outStream.flush();
 290                         outStream.close();
 291                         LOG.debug("file written successfully");
 292                 }
 293                 catch (IOException e) {
 294                         LOG.error("problem writing file:"+e.getMessage());
 295                         return false;
 296                 }
 297                 return true;
 298         }
 299
 300 }