Java Code Examples for java.net.URISyntaxException

/** 
 * Throws if  {@code s} contains characters that are not letters, digits orin  {@code legal}.
 */
public static void validateSimple(String s,String legal) throws URISyntaxException {
  for (int i=0; i < s.length(); i++) {
    char ch=s.charAt(i);
    if (!((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || (ch >= '0' && ch <= '9')|| legal.indexOf(ch) > -1)) {
      throw new URISyntaxException(s,"Illegal character",i);
    }
  }
}
 

private DocumentSource createHTTPDocumentSource(WebResponder responder,String uri,boolean report) throws IOException {
  try {
    if (!isValidURI(uri)) {
      throw new URISyntaxException(uri,"@@@");
    }
    return createHTTPDocumentSource(responder.getRunner().getHTTPClient(),uri);
  }
 catch (  URISyntaxException ex) {
    responder.sendError(400,"Invalid input URI " + uri,report);
    return null;
  }
}
 

public static Map<String,String> parseQuery(String uri) throws URISyntaxException {
  try {
    Map<String,String> rc=new HashMap<String,String>();
    if (uri != null) {
      String[] parameters=uri.split("&");
      for (int i=0; i < parameters.length; i++) {
        int p=parameters[i].indexOf("=");
        if (p >= 0) {
          String name=URLDecoder.decode(parameters[i].substring(0,p),"UTF-8");
          String value=URLDecoder.decode(parameters[i].substring(p + 1),"UTF-8");
          rc.put(name,value);
        }
 else {
          rc.put(parameters[i],null);
        }
      }
    }
    return rc;
  }
 catch (  UnsupportedEncodingException e) {
    throw (URISyntaxException)new URISyntaxException(e.toString(),"Invalid encoding").initCause(e);
  }
}
 

private QueryData extractSaltIds(String saltIds){
  QueryData queryData=new QueryData();
  SaltURIs uris=new SaltURIs();
  for (  String id : saltIds.split("\\s")) {
    java.net.URI uri;
    try {
      uri=new java.net.URI(id);
      if (!"salt".equals(uri.getScheme()) || uri.getFragment() == null) {
        throw new URISyntaxException("not a salt id",uri.toString());
      }
    }
 catch (    URISyntaxException ex) {
      log.error(null,ex);
      continue;
    }
    uris.add(uri);
  }
  Set<String> corpusNames=new TreeSet<String>();
  List<QueryNode> pseudoNodes=new ArrayList<QueryNode>(uris.size());
  for (  java.net.URI u : uris) {
    pseudoNodes.add(new QueryNode());
    corpusNames.add(CommonHelper.getCorpusPath(u).get(0));
  }
  List<Long> corpusIDs=annisDao.mapCorpusNamesToIds(new LinkedList<String>(corpusNames));
  queryData.setCorpusList(corpusIDs);
  queryData.addAlternative(pseudoNodes);
  log.debug(uris.toString());
  queryData.addExtension(uris);
  return queryData;
}
 

private static void init(){
  File projectRoot;
  String globalVersion;
  File assemblyDir;
  try {
    URL location=ITUtil.class.getProtectionDomain().getCodeSource().getLocation();
    File pomRoot=findPomRoot(new File(location.toURI()));
    projectRoot=pomRoot.getParentFile();
    globalVersion=getLocalVersion(pomRoot);
    File targetDir=new File(pomRoot,"target");
    if (!targetDir.exists()) {
      throw new IllegalStateException("probably haven't run 'package' yet");
    }
    assemblyDir=new File(new File(targetDir,"aardvark-" + globalVersion + "-bin"),"aardvark-" + globalVersion);
  }
 catch (  URISyntaxException e) {
    throw new RuntimeException(e);
  }
  _projectRoot=projectRoot;
  _globalVersion=globalVersion;
  _assemblyDir=assemblyDir;
}
 

/** 
 * Load the configuration from a URL.  This understands any URL that the JVM has a protocol handler for, and also "classpath:" URLs. 
 * @return the configuration or null
 * @param urlString the URL for the config file
 * @throws URISyntaxException 
 * @throws MalformedURLException 
 */
public C loadConfigurationFromUrl(String urlString) throws ConfigurationException {
  InputStream is=null;
  try {
    URI uri=new URI(urlString);
    if (uri.getScheme().equals("classpath")) {
      String path=uri.getSchemeSpecificPart();
      LOG.debug("Loading configuration from classpath resource '" + path + "'");
      is=JsonConfigLoader.class.getClassLoader().getResourceAsStream(path);
      if (is == null) {
        throw new IllegalArgumentException("Cannot locate resource '" + path + "' on the classpath");
      }
    }
 else {
      LOG.debug("Loading configuration from url '" + urlString + "'");
      is=uri.toURL().openStream();
    }
    return readConfiguration(is);
  }
 catch (  URISyntaxException ex) {
    throw new IllegalArgumentException("Invalid urlString '" + urlString + "'",ex);
  }
catch (  MalformedURLException ex) {
    throw new IllegalArgumentException("Invalid urlString '" + urlString + "'",ex);
  }
catch (  IOException ex) {
    throw new ConfigurationException("Cannot open URL input stream",ex);
  }
 finally {
    closeQuietly(is);
  }
}
 

private String getOutputDirectory(CtClass modelClass) throws NotFoundException, URISyntaxException {
  URL u=modelClass.getURL();
  String file=u.getFile();
  file=file.substring(0,file.length() - 6);
  String className=modelClass.getName();
  className=className.replace(".","/");
  return file.substring(0,file.indexOf(className));
}
 

public static ConnectionManager createConnectionManager(String url,String username,String password,Properties properties) throws DbException {
  if (url == null) {
    throw new IllegalArgumentException("Connection url can not be null");
  }
  try {
    URI uri=new URI(url);
    String adbcjProtocol=uri.getScheme();
    if (!ADBCJ_PROTOCOL.equals(adbcjProtocol)) {
      throw new DbException("Invalid connection URL: " + url);
    }
    URI driverUri=new URI(uri.getSchemeSpecificPart());
    String protocol=driverUri.getScheme();
    ServiceLoader<ConnectionManagerFactory> serviceLoader=ServiceLoader.load(ConnectionManagerFactory.class);
    for (    ConnectionManagerFactory factory : serviceLoader) {
      if (factory.canHandle(protocol)) {
        return factory.createConnectionManager(url,username,password,properties);
      }
    }
    throw new DbException("Could not find ConnectionManagerFactory for protocol '" + protocol + "'");
  }
 catch (  URISyntaxException e) {
    throw new DbException("Invalid connection URL: " + url);
  }
}
 

private URI toUri(String path){
  try {
    return new URI(null,null,path,null);
  }
 catch (  URISyntaxException e) {
    throw new IllegalStateException(e);
  }
}
 

public void onClick(View v){
  URIish uri;
  try {
    uri=getCloneUri();
  }
 catch (  URISyntaxException e) {
    Toast.makeText(v.getContext(),"bad dog",10).show();
    return;
  }
  File checkoutLocation=getTargetFolder();
  boolean bare=bareRepoCheckbox.isChecked();
  try {
    launchClone(uri,checkoutLocation,bare);
  }
 catch (  Exception e) {
    Toast.makeText(v.getContext(),"ARRG: " + e,10).show();
    e.printStackTrace();
  }
}
 

private <T>HttpResult<T> doGet(Type target){
  try {
    URI path=createPath(address,query());
    HttpGet get=new HttpGet(path);
    return doRequest(get,target);
  }
 catch (  URISyntaxException e) {
    Log.e(Constants.TAG,"Couldn't create path",e);
    return error();
  }
}
 

@LegacyConfig(value="home-page-url",replacedBy="home-page") public PersonConfig setHomePageUrl(URL homePage){
  try {
    this.homePage=homePage.toURI();
    return this;
  }
 catch (  URISyntaxException e) {
    throw new IllegalArgumentException(e);
  }
}
 

static URI validateId(URI blobId) throws UnsupportedIdException {
  if (blobId == null)   throw new NullPointerException("Id cannot be null");
  if (!blobId.getScheme().equalsIgnoreCase(scheme))   throw new UnsupportedIdException(blobId,"Id must be in " + scheme + " scheme");
  String path=blobId.getRawSchemeSpecificPart();
  if (path.startsWith("/"))   throw new UnsupportedIdException(blobId,"Id must specify a relative path");
  try {
    URI tmp=new URI(scheme + ":/" + path);
    String nPath=tmp.normalize().getRawSchemeSpecificPart().substring(1);
    if (nPath.equals("..") || nPath.startsWith("../"))     throw new UnsupportedIdException(blobId,"Id cannot be outside top-level directory");
    if (nPath.endsWith("/"))     throw new UnsupportedIdException(blobId,"Id cannot specify a directory");
    return new URI(scheme + ":" + nPath);
  }
 catch (  URISyntaxException wontHappen) {
    throw new Error(wontHappen);
  }
}
 

@GET public Response authorize(@Context HttpServletRequest request) throws URISyntaxException, OAuthSystemException {
  OAuthAuthzRequest oauthRequest=null;
  OAuthIssuerImpl oauthIssuerImpl=new OAuthIssuerImpl(new MD5Generator());
  try {
    oauthRequest=new OAuthAuthzRequest(request);
    String responseType=oauthRequest.getParam(OAuth.OAUTH_RESPONSE_TYPE);
    OAuthASResponse.OAuthAuthorizationResponseBuilder builder=OAuthASResponse.authorizationResponse(request,HttpServletResponse.SC_FOUND);
    if (responseType.equals(ResponseType.CODE.toString())) {
      builder.setCode(oauthIssuerImpl.authorizationCode());
    }
    if (responseType.equals(ResponseType.TOKEN.toString())) {
      builder.setAccessToken(oauthIssuerImpl.accessToken());
      builder.setExpiresIn(3600l);
    }
    String redirectURI=oauthRequest.getParam(OAuth.OAUTH_REDIRECT_URI);
    final OAuthResponse response=builder.location(redirectURI).buildQueryMessage();
    URI url=new URI(response.getLocationUri());
    return Response.status(response.getResponseStatus()).location(url).build();
  }
 catch (  OAuthProblemException e) {
    final Response.ResponseBuilder responseBuilder=Response.status(HttpServletResponse.SC_FOUND);
    String redirectUri=e.getRedirectUri();
    if (OAuthUtils.isEmpty(redirectUri)) {
      throw new WebApplicationException(responseBuilder.entity("OAuth callback url needs to be provided by client!!!").build());
    }
    final OAuthResponse response=OAuthASResponse.errorResponse(HttpServletResponse.SC_FOUND).error(e).location(redirectUri).buildQueryMessage();
    final URI location=new URI(response.getLocationUri());
    return responseBuilder.location(location).build();
  }
}
 

public URI getUri(String name){
  if (containsKey(name)) {
    try {
      return new URI(get(name));
    }
 catch (    URISyntaxException e) {
      throw new IllegalArgumentException(e.getMessage());
    }
  }
 else {
    throw new UndefinedPropertyException("Missing required property '" + name + "'");
  }
}
 

/** 
 * Constructs a  {@link URI} using all the parameters. This should beused instead of {@link URI#URI(String,String,String,int,String,String,String)}or any of the other URI multi-argument URI constructors.
 * @param scheme Scheme name
 * @param host Host name
 * @param port Port number
 * @param path Path
 * @param query Query
 * @param fragment Fragment
 * @throws URISyntaxException If both a scheme and a path are given but the path is relative, if the URI string constructed from the given components violates RFC 2396, or if the authority component of the string is present but cannot be parsed as a server-based authority
 */
public static URI createURI(final String scheme,final String host,int port,final String path,final String query,final String fragment) throws URISyntaxException {
  StringBuilder buffer=new StringBuilder();
  if (host != null) {
    if (scheme != null) {
      buffer.append(scheme);
      buffer.append("://");
    }
    buffer.append(host);
    if (port > 0) {
      buffer.append(':');
      buffer.append(port);
    }
  }
  if (path == null || !path.startsWith("/")) {
    buffer.append('/');
  }
  if (path != null) {
    buffer.append(path);
  }
  if (query != null) {
    buffer.append('?');
    buffer.append(query);
  }
  if (fragment != null) {
    buffer.append('#');
    buffer.append(fragment);
  }
  return new URI(buffer.toString());
}
 

/** 
 * suitable for namespacing
 * @return the uri with relative schema ( ex. //facebook.com/path/to/stuff?query )
 */
public static URI createNamespaceUri(Object uriStr){
  URI temp=createUriWithOptions(uriStr,true,true);
  try {
    URI namesUri=new URI(null,temp.getUserInfo(),temp.getHost(),-1,temp.getPath(),temp.getQuery(),temp.getFragment());
    return namesUri;
  }
 catch (  URISyntaxException e) {
    return null;
  }
}
 

public void downloadFont(String font) throws InstallException {
  log.debug("Download font " + font);
  URI source=null;
  try {
    source=new URI(FONT_DOWNLOAD_URL + font);
  }
 catch (  URISyntaxException use) {
    log.error("Invalid URI",use);
    throw new InstallException("Error downloading font");
  }
  File target=new File(SharedConstants.FONT_DIR,font);
  GenericFileDownloader downloader=new GenericFileDownloader();
  downloader.downloadFileInBackground(source,target,"font");
}
 

public int headRequest(String Uri) throws RestConnectionException {
  initialize();
  HttpHead request=new HttpHead();
  try {
    requestUri=new URI(Uri);
  }
 catch (  URISyntaxException e) {
    e.printStackTrace();
  }
  setCredentials();
  request.setURI(requestUri);
  Log.d("HEAD Request URL",Uri);
  try {
    response=client.execute(request);
    Log.d("Response status",response.getStatusLine().toString());
    return response.getStatusLine().getStatusCode();
  }
 catch (  ClientProtocolException e) {
    e.printStackTrace();
  }
catch (  IOException e) {
    e.printStackTrace();
    throw new RestConnectionException(e);
  }
  return -1;
}
 

private String getSafeURL(String badURL,String name){
  URI uri=null;
  try {
    uri=new URI("https",badURL.substring(8),"/" + name.toString() + "/","");
  }
 catch (  URISyntaxException e1) {
    e1.printStackTrace();
  }
  String url=null;
  try {
    url=uri.toURL().toString();
  }
 catch (  MalformedURLException e1) {
    e1.printStackTrace();
  }
  return url.substring(0,url.length() - 1);
}
 

private boolean verifyUrl(int color){
  try {
    new URI(mUrlTextbox.getText().toString());
    mUrlTextbox.setTextColor(color);
    return true;
  }
 catch (  URISyntaxException e) {
    mUrlTextbox.setTextColor(Color.RED);
    return false;
  }
}
 

public String normalizeRequestUrl() throws URISyntaxException {
  URI uri=new URI(request.getRequestUrl());
  String scheme=uri.getScheme().toLowerCase();
  String authority=uri.getAuthority().toLowerCase();
  boolean dropPort=(scheme.equals("http") && uri.getPort() == 80) || (scheme.equals("https") && uri.getPort() == 443);
  if (dropPort) {
    int index=authority.lastIndexOf(":");
    if (index >= 0) {
      authority=authority.substring(0,index);
    }
  }
  String path=uri.getRawPath();
  if (path == null || path.length() <= 0) {
    path="/";
  }
  return scheme + "://" + authority+ path;
}
 

private byte[] download(String pathToDownload) throws IOException, URISyntaxException {
  Connection connection;
  final Host host=HostFactory.host;
  if (host != null) {
    connection=Connection.getInstance(host.addr,host.port);
    connection.setAuth(host.user,host.pass);
  }
 else {
    connection=Connection.getInstance(null,0);
  }
  return connection.download(pathToDownload);
}
 

public synchronized Object connect(ID remote,Object data,int timeout) throws ECFException {
  Log.d(TAG,"connect(" + remote + ","+ data+ ","+ timeout+ ")");
  if (socket != null)   throw new ECFException(Messages.Client_Already_Connected);
  URI anURI=null;
  try {
    anURI=new URI(remote.getName());
  }
 catch (  final URISyntaxException e) {
    throw new ECFException(Messages.Client_Invalid_URI + remote,e);
  }
  SocketFactory fact=SocketFactory.getSocketFactory();
  if (fact == null)   fact=SocketFactory.getDefaultSocketFactory();
  ConnectResultMessage res=null;
  try {
    keepAlive=timeout;
    final Socket s=fact.createSocket(anURI.getHost(),anURI.getPort(),keepAlive);
    setSocketOptions(s);
    setSocket(s);
    outputStream=new ObjectOutputStream(s.getOutputStream());
    outputStream.flush();
    inputStream=new ObjectInputStream(s.getInputStream());
    debug("connect;" + anURI);
    send(new ConnectRequestMessage(anURI,(Serializable)data));
    res=(ConnectResultMessage)readObject();
  }
 catch (  final Exception e) {
    throw new ECFException("Exception during connection to " + remote.getName(),e);
  }
  debug("connect;rcv:" + res);
  setupThreads();
  final Object ret=res.getData();
  debug("connect;returning:" + ret);
  return ret;
}
 

public static LookupWord splitWord(String word){
  if (word == null || word.equals("") || word.equals("#")) {
    return new LookupWord();
  }
  try {
    return splitWordAsURI(word);
  }
 catch (  URISyntaxException e) {
    Log.d(TAG,"Word is not proper URI: " + word);
    return splitWordSimple(word);
  }
}
 

@Override public URI deserialize(JsonElement json,Type typeOfT,JsonDeserializationContext context) throws JsonParseException {
  try {
    return new URI(json.getAsString());
  }
 catch (  URISyntaxException e) {
    throw new JsonSyntaxException(e);
  }
}
 

/** 
 * Get a fresh request token from the service provider.
 * @param accessor should contain a consumer that contains a non-null consumerKey and consumerSecret. Also, accessor.consumer.serviceProvider.requestTokenURL should be the URL (determined by the service provider) for getting a request token.
 * @param httpMethod typically OAuthMessage.POST or OAuthMessage.GET, or null to use the default method.
 * @param parameters additional parameters for this request, or null to indicate that there are no additional parameters.
 * @throws OAuthProblemException the HTTP response status code was not 200 (OK)
 */
public void getRequestToken(OAuthAccessor accessor,String httpMethod,Collection<? extends Map.Entry> parameters) throws IOException, OAuthException, URISyntaxException {
  accessor.accessToken=null;
  accessor.tokenSecret=null;
{
    Object accessorSecret=accessor.getProperty(OAuthConsumer.ACCESSOR_SECRET);
    if (accessorSecret != null) {
      List<Map.Entry> p=(parameters == null) ? new ArrayList<Map.Entry>(1) : new ArrayList<Map.Entry>(parameters);
      p.add(new OAuth.Parameter("oauth_accessor_secret",accessorSecret.toString()));
      parameters=p;
    }
  }
  OAuthMessage response=invoke(accessor,httpMethod,accessor.consumer.serviceProvider.requestTokenURL,parameters);
  accessor.requestToken=response.getParameter(OAuth.OAUTH_TOKEN);
  accessor.tokenSecret=response.getParameter(OAuth.OAUTH_TOKEN_SECRET);
  response.requireParameters(OAuth.OAUTH_TOKEN,OAuth.OAUTH_TOKEN_SECRET);
}
 

public String getFriendlyNameForUri(String uri){
  if (uri == null) {
    return null;
  }
  try {
    Intent intent=Intent.parseUri(uri,0);
    if (Intent.ACTION_MAIN.equals(intent.getAction())) {
      return getFriendlyActivityName(intent,false);
    }
    return getFriendlyShortcutName(intent);
  }
 catch (  URISyntaxException e) {
  }
  return uri;
}
 

public static String writeHttpDataInDirectory(Context context,String uri,String path){
  long crc64=Utils.Crc64Long(uri);
  if (!isCached(crc64,1024)) {
    Bitmap bitmap;
    try {
      bitmap=UriTexture.createFromUri(context,uri,1024,1024,crc64,null);
    }
 catch (    OutOfMemoryError e) {
      return null;
    }
catch (    IOException e) {
      return null;
    }
catch (    URISyntaxException e) {
      return null;
    }
    bitmap.recycle();
  }
  String fileString=createFilePathFromCrc64(crc64,1024);
  try {
    File file=new File(fileString);
    if (file.exists()) {
      String newPath=path + (path.endsWith("/") ? "" : "/") + crc64+ ".jpg";
      File newFile=new File(newPath);
      Utils.Copy(file,newFile);
      return newPath;
    }
    return null;
  }
 catch (  Exception e) {
    return null;
  }
}
 

private boolean addShortcut(SQLiteDatabase sqlitedatabase,ContentValues contentvalues,TypedArray typedarray){
  label0: {
    Resources resources=mContext.getResources();
    int i=typedarray.getResourceId(7,0);
    int j=typedarray.getResourceId(8,0);
    String s=null;
    boolean flag;
    Intent intent;
    try {
      s=typedarray.getString(9);
      intent=Intent.parseUri(s,0);
    }
 catch (    URISyntaxException urisyntaxexception) {
      Log.w("Launcher.LauncherProvider",(new StringBuilder()).append("Shortcut has malformed uri: ").append(s).toString());
      urisyntaxexception.printStackTrace();
      flag=false;
      if (false)       ;
 else       break label0;
    }
    if (i == 0 || j == 0) {
      Log.w("Launcher.LauncherProvider","Shortcut is missing title or icon resource ID");
      flag=false;
    }
 else {
      intent.setFlags(0x10000000);
      contentvalues.put("intent",intent.toUri(0));
      contentvalues.put("title",resources.getString(j));
      contentvalues.put("itemType",Integer.valueOf(1));
      contentvalues.put("spanX",Integer.valueOf(1));
      contentvalues.put("spanY",Integer.valueOf(1));
      contentvalues.put("iconType",Integer.valueOf(0));
      contentvalues.put("iconPackage",mContext.getPackageName());
      contentvalues.put("iconResource",mContext.getResources().getResourceName(i));
      sqlitedatabase.insert("favorites",null,contentvalues);
      flag=true;
    }
  }
  return flag;
}
 

/** 
 * Process the text string
 * @return the processed string, with downloaded resource names substituted
 */
public String processString(){
  if (extras != null) {
    try {
      Set<String> keys=extras.keySet();
      for (      String key : keys) {
        if (key.startsWith(GET_PREFIX)) {
          String rawUri=extras.getString(key);
          String rawKey=key.substring(GET_PREFIX.length());
          URI uri=new URI(rawUri);
          String filename=ModuleUtils.getResourceUriHash(rawUri);
          uriMap.put(rawKey,uri);
          filenameMap.put(rawKey,filename);
        }
      }
    }
 catch (    URISyntaxException e) {
      Log.v(TAG,"process exception: aborting; exception: " + e);
      return null;
    }
    for (    String key : uriMap.keySet()) {
      try {
        ModuleUtils.getResource(uriMap.get(key),filenameMap.get(key));
      }
 catch (      IOException e) {
        Log.v(TAG,"process exception: aborting; exception: " + e + "; resource = "+ uriMap.get(key).toString());
        return null;
      }
    }
    for (    String key : filenameMap.keySet()) {
      text=text.replace("%" + key,Constants.RESOURCE_DIR + '/' + filenameMap.get(key));
    }
  }
  return text;
}
 

/** 
 * Reads the given location file and returns the location that is stored inside the location as a File. <p> The file returned by this method may not exist, no check is performed here, thus you have to check for the existence of the file (and propably for the correct type too). </p> <p> You might want to use  {@link #getProjectDirectory(File)} to receive a pointer to a valid, existing Eclipse projectfile </p>
 * @param locationfile The file which contains the desired data.
 * @return The location stored in the .location file (typically the root-folder of an external project) or null if nolocation could be read from the .location file
 * @throws IOException
 */
static final File readLocation(File locationfile) throws IOException {
  Assure.isFile("locationfile",locationfile);
  ChunkyFile cf=new ChunkyFile(locationfile);
  if (cf.getChunkCount() == 1) {
    byte[] data=cf.getChunk(0);
    DataInputStream datain=new DataInputStream(new ByteArrayInputStream(data));
    String location=datain.readUTF();
    File file=null;
    if (location.length() > 0) {
      if (location.startsWith(URI_PREFIX)) {
        URI uri=URI.create(location.substring(URI_PREFIX.length()));
        if (!uri.getScheme().startsWith("file")) {
          A4ELogging.debug("LocationFileParser.readLocation(): the stored location uri '%s' is not a file-uri",uri);
        }
 else {
          file=new File(uri);
        }
      }
 else {
        try {
          file=new File(new URI(location));
        }
 catch (        URISyntaxException ex) {
          A4ELogging.debug("LocationFileParser.readLocation(): the location '%s' will be interpreted as a path",location);
          file=new File(location);
        }
catch (        IllegalArgumentException ex) {
          A4ELogging.debug("LocationFileParser.readLocation(): the location '%s' will be interpreted as a path",location);
          file=new File(location);
        }
      }
      return file;
    }
  }
 else {
    A4ELogging.warn("the file '%s' contains %d chunks instead of a single one",locationfile,Integer.valueOf(cf.getChunkCount()));
  }
  return null;
}
 

private static void processLocation(URL doc,Queue<File> pending,String location){
  try {
    URI locUri=new URI(location);
    if (locUri.isAbsolute()) {
      return;
    }
    locUri=doc.toURI().resolve(locUri);
    pending.add(new File(locUri));
  }
 catch (  URISyntaxException e) {
    logException(e);
  }
}
 

/** 
 * Takes a string that looks like a URL and performs an operation based on the contents of the URL. Currently only starting activities is supported. <p> Supported URL type follows: <ul> <li> {@code and-activity://<Activity class name>}<br> start specified activity </ul>
 */
@Override public void get(String url){
  URI dest;
  try {
    dest=new URI(url);
  }
 catch (  URISyntaxException exception) {
    throw new IllegalArgumentException(exception);
  }
  if (!"and-activity".equals(dest.getScheme())) {
    throw new WebDriverException("Unrecognized scheme in URI: " + dest.toString());
  }
 else   if (!Strings.isNullOrEmpty(dest.getPath())) {
    throw new WebDriverException("Unrecognized path in URI: " + dest.toString());
  }
  Class<?> clazz;
  try {
    clazz=Class.forName(dest.getAuthority());
  }
 catch (  ClassNotFoundException exception) {
    throw new WebDriverException("The specified Activity class does not exist: " + dest.getAuthority(),exception);
  }
  for (  NameValuePair nvp : URLEncodedUtils.parse(dest,"utf8")) {
    if ("id".equals(nvp.getName())) {
      throw new WebDriverException("Moving to the specified activity is not supported.");
    }
  }
  startActivity(clazz);
}
 

/** 
 * @param path The path to the file relative to this plugin's root
 * @param bundle The bundle containing information as to where is this plugin
 * @return A File pointing to the system file or null if the activator is not set or could notfind the file (this is not a regular RCP run... happens for non-plugins tests)
 * @throws IOException Thrown if there is an error while reading the file
 */
public static File resolveFile(String path,Bundle bundle) throws IOException {
  File file=null;
  if (bundle != null) {
    URL url=FileLocator.find(bundle,new Path(path),Collections.emptyMap());
    if (url != null) {
      URL fileUrl=FileLocator.toFileURL(url);
      try {
        file=new File(fileUrl.toURI());
      }
 catch (      URISyntaxException e) {
        e.printStackTrace();
      }
    }
  }
  return file;
}
 

private String resolve(String context,String spec){
  try {
    URL cUrl=new URL(context);
    URL resolved=new URL(cUrl,spec);
    return resolved.toURI().toASCIIString();
  }
 catch (  URISyntaxException e) {
  }
catch (  MalformedURLException e) {
  }
catch (  NullPointerException e) {
  }
  return spec;
}
 

/** 
 * @return the rootContextUrl
 */
public String getRootContextUrl(){
  try {
    return constructRootContext().toURI().toString();
  }
 catch (  MalformedURLException e) {
    throw new IllegalArgumentException("Application name, namespace and Libra Domain does not represent a valid URL",e);
  }
catch (  URISyntaxException e) {
    throw new RuntimeException("Application name, namespace and Libra Domain does not represent a valid URL",e);
  }
}
 

@Override public void validate() throws ConfigurationException {
  Validate.notNullOrEmpty(bindAddress,"Bind address must not be null or empty");
  Validate.isInRange(jmxPort,0,MAX_PORT,"JMX port must be in interval ]" + MIN_PORT + ","+ MAX_PORT+ "[, but was "+ jmxPort);
  try {
    this.setJmxUri(createJmxUri());
    this.setManagerUrl(createManagerUrl());
  }
 catch (  URISyntaxException ex) {
    throw new ConfigurationException("JMX URI is not valid, please provide ",ex);
  }
catch (  MalformedURLException e) {
    throw new ConfigurationException("JMX URI is not valid",e);
  }
}
 

@Override public Object lookup(ArquillianResource resource,Annotation... qualifiers){
  Object object=super.lookup(resource,qualifiers);
  if (object == null) {
    return object;
  }
  try {
    return ((URL)object).toURI();
  }
 catch (  URISyntaxException e) {
    throw new RuntimeException("Could not convert URL to URI: " + object,e);
  }
}
 

private boolean existsInGivenLocation(String location){
  try {
    final URL url=load(location);
    if (url == null) {
      return false;
    }
  }
 catch (  URISyntaxException e) {
    throw new InvalidResourceLocation("Unable to open resource file in " + location,e);
  }
  return true;
}
 

/** 
 * A helper converting method. Converts string to a class of given type
 * @param value String value to be converted
 * @param to Type of desired value
 * @param < T > Type of returned value
 * @return Value converted to a appropriate type
 */
public <T>T convert(String value,Class<T> to){
  if (String.class.equals(to)) {
    return to.cast(value);
  }
 else   if (Integer.class.equals(to)) {
    return to.cast(Integer.valueOf(value));
  }
 else   if (Double.class.equals(to)) {
    return to.cast(Double.valueOf(value));
  }
 else   if (Long.class.equals(to)) {
    return to.cast(Long.valueOf(value));
  }
 else   if (Boolean.class.equals(to)) {
    return to.cast(Boolean.valueOf(value));
  }
 else   if (URL.class.equals(to)) {
    try {
      return to.cast(new URI(value).toURL());
    }
 catch (    MalformedURLException e) {
      throw new IllegalArgumentException("Unable to convert value " + value + " to URL",e);
    }
catch (    URISyntaxException e) {
      throw new IllegalArgumentException("Unable to convert value " + value + " to URL",e);
    }
  }
 else   if (URI.class.equals(to)) {
    try {
      return to.cast(new URI(value));
    }
 catch (    URISyntaxException e) {
      throw new IllegalArgumentException("Unable to convert value " + value + " to URL",e);
    }
  }
  throw new IllegalArgumentException("Unable to convert value " + value + "to a class: "+ to.getName());
}
 

private void initContextRoot(){
  try {
    this.contextRoot=new URI("http://localhost:8080").toURL();
  }
 catch (  MalformedURLException e) {
    throw new IllegalStateException("Unable to set default value for contextRoot",e);
  }
catch (  URISyntaxException e) {
    throw new IllegalStateException("Unable to set default value for contextRoot",e);
  }
}
 

private void initContextRoot(){
  try {
    this.contextRoot=new URI("http://localhost:8080").toURL();
  }
 catch (  MalformedURLException e) {
    throw new IllegalStateException("Unable to set default value for contextRoot",e);
  }
catch (  URISyntaxException e) {
    throw new IllegalStateException("Unable to set default value for contextRoot",e);
  }
}
 

/** 
 * Generate the init script from the Artifactory URL.
 * @return The generated script.
 */
public String generateInitScript() throws URISyntaxException, IOException, InterruptedException {
  StringBuilder initScript=new StringBuilder();
  InputStream templateStream=getClass().getResourceAsStream("/initscripttemplate.gradle");
  String templateAsString=IOUtils.toString(templateStream,Charsets.UTF_8.name());
  File localGradleExtractorJar=Which.jarFile(getClass().getResource("/initscripttemplate.gradle"));
  FilePath dependencyDir=PluginDependencyHelper.getActualDependencyDirectory(build,localGradleExtractorJar);
  String absoluteDependencyDirPath=dependencyDir.getRemote();
  absoluteDependencyDirPath=absoluteDependencyDirPath.replace("\\","/");
  String str=templateAsString.replace("${pluginLibDir}",absoluteDependencyDirPath);
  initScript.append(str);
  return initScript.toString();
}
 

private boolean loginIfNot(HttpServletRequest request,HttpServletResponse response) throws ServletException {
  if (userManager.getRemoteUsername(request) == null) {
    try {
      URI currentUri=new URI(request.getRequestURI());
      URI loginUri=loginUriProvider.getLoginUri(currentUri);
      response.sendRedirect(loginUri.toASCIIString());
    }
 catch (    URISyntaxException e) {
      throw new ServletException(e);
    }
catch (    IOException e) {
      throw new ServletException(e);
    }
    return true;
  }
  return false;
}
 

/** 
 * Connects to Socket server and returns  {@code true} it everithing went ok
 * @return boolean
 */
public void connect() throws ServiceException {
  log.info("Trying to connect to server");
  if (this.isConnected()) {
    this.disconnect();
    this.wasConnected=false;
  }
  if (this.audiobox.getUser() != null) {
    String urlStr=this.getServerUrl();
    URL url=null;
    try {
      url=new URL(urlStr);
      log.info("Server will be " + url.toURI().toString());
    }
 catch (    MalformedURLException e) {
      log.error("Invalid url found");
      throw new ServiceException("No valid URL for server found");
    }
catch (    URISyntaxException e) {
      log.error("Invalid url found");
      throw new ServiceException("No valid URL for server found");
    }
    this.socket=new SocketIO(url);
    this.socket.addHeader(IConnector.X_AUTH_TOKEN_HEADER,this.audiobox.getUser().getAuthToken());
    this.socket.connect(this);
  }
 else {
    this.wasConnected=true;
  }
}
 

@Test public void testCanReadTemplateFilesOnTheFilesystem() throws IOException, URISyntaxException {
  String schemaSrcPath="src/test/resources/simple_record.avsc";
  String velocityTemplateDir="src/main/velocity/org/apache/avro/compiler/specific/templates/java/classic/";
  File src=new File(schemaSrcPath);
  Schema.Parser parser=new Schema.Parser();
  Schema schema=parser.parse(src);
  SpecificCompiler compiler=new SpecificCompiler(schema);
  compiler.setTemplateDir(velocityTemplateDir);
  compiler.setStringType(StringType.CharSequence);
  File outputDir=AvroTestUtil.tempDirectory(getClass(),"specific-output");
  compiler.compileToDestination(src,outputDir);
  assertTrue(new File(outputDir,"SimpleRecord.java").exists());
}
 

private static ClientConfiguration createClientConfiguration(String secureEndpoint){
  ClientConfiguration config=new ClientConfiguration();
  AwsClientUtils clientUtils=new AwsClientUtils();
  config.setUserAgent(clientUtils.formUserAgentString("AWS-Toolkit-For-Eclipse",AwsToolkitCore.getDefault()));
  AwsToolkitCore plugin=AwsToolkitCore.getDefault();
  if (plugin != null) {
    IProxyService proxyService=AwsToolkitCore.getDefault().getProxyService();
    if (proxyService.isProxiesEnabled()) {
      try {
        IProxyData[] proxyData;
        proxyData=proxyService.select(new URI(secureEndpoint));
        if (proxyData.length > 0) {
          config.setProxyHost(proxyData[0].getHost());
          config.setProxyPort(proxyData[0].getPort());
          if (proxyData[0].isRequiresAuthentication()) {
            config.setProxyUsername(proxyData[0].getUserId());
            config.setProxyPassword(proxyData[0].getPassword());
          }
        }
      }
 catch (      URISyntaxException e) {
        plugin.getLog().log(new Status(Status.ERROR,AwsToolkitCore.PLUGIN_ID,e.getMessage(),e));
      }
    }
  }
  return config;
}
 

public URI getUri(String name){
  if (containsKey(name)) {
    try {
      return new URI(get(name));
    }
 catch (    URISyntaxException e) {
      throw new IllegalArgumentException(e.getMessage());
    }
  }
 else {
    throw new UndefinedPropertyException("Missing required property '" + name + "'");
  }
}
 

protected void setAudienceUris(SamlTokenValidator validator) throws FederationException {
  String[] audienceUris=FederatedConfiguration.getInstance().getAudienceUris();
  for (  String audienceUriStr : audienceUris) {
    try {
      validator.getAudienceUris().add(new URI(audienceUriStr));
    }
 catch (    URISyntaxException e) {
      throw new FederationException("Federated Login Configuration failure: Invalid Audience URI",e);
    }
  }
}
 

/** 
 * The method adds the log message to the Windows Azure Table storage depending upon the layout.
 * @param event 
 */
@Override protected synchronized void append(LoggingEvent event){
  String messageLevel=event.getLevel().toString();
  if (this.layout == null) {
    errorHandler.error("layout not specified",null,ErrorCode.MISSING_LAYOUT);
    return;
  }
  String message=this.layout.format(event);
  try {
    CloudTableClient cloudTableClient=TableClient.getTableClient(storageEndpoint,accountName,accountKey,tableName);
    makeEntryIntoAzureTableStorage(cloudTableClient,messageLevel,message);
  }
 catch (  InvalidKeyException e) {
    e.printStackTrace();
  }
catch (  StorageException e) {
    e.printStackTrace();
  }
catch (  URISyntaxException e) {
    e.printStackTrace();
  }
}
 

/** 
 * Sign a property Map with OAuth.
 * @param url		the url where the request is to be made
 * @param props		the map of properties to sign
 * @param method	the HTTP request method, eg POST
 * @param key		the oauth_consumer_key
 * @param secret	the shared secret
 * @return
 */
public static Map<String,String> signProperties(String url,Map<String,String> props,String method,String key,String secret){
  if (key == null || secret == null) {
    log.error("Error in signProperties - key and secret must be specified");
    return null;
  }
  OAuthMessage oam=new OAuthMessage(method,url,props.entrySet());
  OAuthConsumer cons=new OAuthConsumer("about:blank",key,secret,null);
  OAuthAccessor acc=new OAuthAccessor(cons);
  try {
    oam.addRequiredParameters(acc);
    log.info("Base Message String\n" + OAuthSignatureMethod.getBaseString(oam) + "\n");
    List<Map.Entry<String,String>> params=oam.getParameters();
    Map<String,String> headers=new HashMap<String,String>();
    for (    Map.Entry<String,String> p : params) {
      String param=URLEncoder.encode(p.getKey(),CHARSET);
      String value=p.getValue();
      String encodedValue=value != null ? URLEncoder.encode(value,CHARSET) : "";
      headers.put(param,encodedValue);
    }
    return headers;
  }
 catch (  OAuthException e) {
    log.error(e.getClass() + ":" + e.getMessage());
    return null;
  }
catch (  IOException e) {
    log.error(e.getClass() + ":" + e.getMessage());
    return null;
  }
catch (  URISyntaxException e) {
    log.error(e.getClass() + ":" + e.getMessage());
    return null;
  }
}