@Override
    public void run() {

      while (true) {
        if (curQue.get() < 0) {
          if (isTraceEnabled) {
            logger.trace("Thread {} is leaving traversing job.", Thread.currentThread().getName());
          }
          break;
        }
        int curQueTemp = curQue.get();
        VectorClock G = ques[curQueTemp].poll();
        try {
          if (G == null) {
            barrier.await();
            if (isTraceEnabled) {
              logger.trace(
                  "Thread {} is leaving the barrier and curQue = {}.",
                  Thread.currentThread().getName(),
                  curQueTemp);
            }
            continue;
          }
        } catch (InterruptedException e) {
          logger.warn(
              "Thread in the barrier is interrupted: {}", Arrays.toString(e.getStackTrace()));
          break;
        } catch (BrokenBarrierException e) {
          logger.warn(
              "The barrier in {} is broken: {}",
              ConcurrentBFSTraverser.class,
              Arrays.toString(e.getStackTrace()));
          break;
        }

        enumerator.enumerate(poset, G); // evaluate predicate

        for (int i = 0; i < n; ++i) {
          if (!poset.isNextEnabled(G, i)) continue;
          boolean hasDuplicate = false;
          for (int j = 0; j < n; ++j) {
            if (i == j) continue;
            if (poset
                .getVectorClock(i, G.get(i) + 1)
                .isConcurrentWith(poset.getVectorClock(j, G.get(j)))) {
              if (poset.getId(i, G.get(i) + 1) < poset.getId(j, G.get(j))) hasDuplicate = true;
            }
          }
          if (!hasDuplicate) {
            VectorClock H = VectorClock.copyOf(G);
            H.set(i, G.get(i) + 1);
            if (isTraceEnabled) logger.trace("Adding a frontier to next level of que.");
            ques[1 - curQueTemp].add(H);
          }
        }
      }
      enumerator.close();
    }
  public static void main(String[] args) throws IOException {
    byte[] buf = null;
    String msg = null;
    int msgPerSecond = 0;
    /* Try to convert single arguments into Integer */
    try {
      buf = new byte[Integer.valueOf(args[2])];
      msg = randomString(Integer.valueOf(args[3]));
      msgPerSecond = Integer.valueOf(args[4]);
    }
    /* On error give the needed information back as String */
    catch (NumberFormatException ex) {
      System.err.printf(
          "usage: server_name port buffer_size " + "message_length message_per_second\n");
      System.exit(1);
    }

    /* Create socket */
    DatagramSocket datagramSocket = new DatagramSocket(null);

    /* Create local endpoint using bind() */
    SocketAddress localBindPoint = new InetSocketAddress(MYPORT);
    datagramSocket.bind(localBindPoint);

    /* Create remote endpoint */
    SocketAddress remoteBindPoint = new InetSocketAddress(args[0], Integer.valueOf(args[1]));

    /* Create datagram packet for sending message */
    DatagramPacket sendPacket = new DatagramPacket(msg.getBytes(), msg.length(), remoteBindPoint);

    /* Create datagram packet for receiving echoed message */
    DatagramPacket receivePacket = new DatagramPacket(buf, buf.length);
    /* Check if more than one message should be send */
    if (msgPerSecond > 1) {
      do {
        /* Timer that messages were send every second */
        try {
          TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
          System.err.printf(e.getStackTrace().toString());
        }

        /* Send and receive multiple messages */
        for (int it = 0; it < msgPerSecond; it++) {
          sendReceive(datagramSocket, msg, sendPacket, receivePacket);
        }
        System.out.printf("---------------------------------------------------\n");

      } while (true);
    }
    /* Send one single message */
    else {
      sendReceive(datagramSocket, msg, sendPacket, receivePacket);
      System.out.printf("------------- single message sent --------------\n");
    }
  }
Example #3
0
 /**
  * This method will return an UNMODIFIABLE HASH MAP. <b>
  *
  * <h1>~~PLEASE DO NOT MODIFY ANYTHING IN THE MAP~~</h1>
  *
  * </b><br>
  * One can get the DTO/POJO object of each properties file from this map. Key of the DTO/POJO
  * object will be the name of properties file.
  */
 public Map<String, Bean> returnMapValue() {
   updateLock.lock();
   try {
     if (propMap.size() == 0) {
       try {
         logger.debug("Waiting for properties file to upload...");
         logger.info("Reader on HOLD");
         loadCondition.await();
         logger.info("Reader UNHOLD");
       } catch (InterruptedException e) {
         StackTraceElement stackTrace =
             new StackTraceElement("PropReader", "returnMapValue", "com.GR.reader", -1);
         e.setStackTrace(new StackTraceElement[] {stackTrace});
         logger.debug("!!!!!!!!!!!!!!!Exception!!!!!!!!!!!!!!!!");
         logger.debug("Message " + e.getLocalizedMessage());
         for (int i = 1; i <= e.getStackTrace().length; i++) {
           System.out.format("Trace %s: " + e.getStackTrace()[i - 1] + "\n", i++);
         }
         logger.debug("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
       }
     }
     // ----------WILL WAIT UNTILL PROPERTIES FILE ARE UPLOADED----------
     if (priorityFlag) {
       loadCondition.await();
     }
   } catch (InterruptedException e) {
     StackTraceElement stackTrace =
         new StackTraceElement("PropReader", "returnMapValue", "com.GR.reader", -1);
     e.setStackTrace(new StackTraceElement[] {stackTrace});
     logger.debug("!!!!!!!!!!!!!!!Exception!!!!!!!!!!!!!!!!");
     logger.debug("Message " + e.getLocalizedMessage());
     for (int i = 1; i <= e.getStackTrace().length; i++) {
       System.out.format("Trace %s: " + e.getStackTrace()[i - 1] + "\n", i++);
     }
     logger.debug("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
   } finally {
     updateLock.unlock();
   }
   return Collections.unmodifiableMap(propMap);
 }
 /**
  * Una vez que un servidor se ha caido, se inicia un proceso de recuperación del mismo, en el que
  * se recuperan las copias redundantes perdidas y se procura periódicamente volver a establecer la
  * conexión.
  *
  * @param servidorCaido El servidor que se ha caido.
  */
 public static void recuperar(StorageServer servidorCaido) {
   servidorCaido.setOnline(false);
   List<ClipDataToServerRelation> listaDeClipsARecuperar =
       StorageMappingManager.getAndRemoveAllClipDataServerRelationsOfServer(servidorCaido);
   for (ClipDataToServerRelation unClipARecuperar : listaDeClipsARecuperar) {
     log.debug("Iniciando recuperacion del clip: " + unClipARecuperar.getClipId());
     if (!StorageMappingManager.tengoLaCantidadDeReplicasNecesariasParaElClip(
         unClipARecuperar.getClipId())) {
       log.debug(
           "Recuperacion del clip: " + unClipARecuperar.getClipId() + " se creara una copia");
       ClipData clipData =
           ClipStorageImpl.getInstancia().getClipDataByClipId(unClipARecuperar.getClipId());
       log.debug(
           "Recuperacion del clip: "
               + unClipARecuperar.getClipId()
               + " se leyó el clip de otro servidor");
       List<StorageServer> servidoresDisponiblesSinEsteClip =
           StorageMappingManager.getStorageServersSinClipDataById(unClipARecuperar.getClipId());
       log.debug(
           "Recuperacion del clip: "
               + unClipARecuperar.getClipId()
               + " hay: "
               + servidoresDisponiblesSinEsteClip.size()
               + " servidores disponibles para guardar la copia leída");
       StorageServerCommunicationsHelper.guardarClipEnLosAlgunosDeLosServidores(
           servidoresDisponiblesSinEsteClip, 1, clipData);
       log.debug(
           "Recuperacion del clip: "
               + unClipARecuperar.getClipId()
               + " la copia ha sido guardada");
     }
   }
   servidorCaido.setAmountOfClipDataStored(0);
   while (!servidorCaido.isOnline()) {
     try {
       Thread.sleep(
           Configuration.getIntConfiguration(
               ConfigurationItemsEnum.TIEMPOENTREINTENTOSLEVANTARSERVIDORCAIDO));
       StorageServerCommunicationsHelper.conectarServidor(servidorCaido);
     } catch (InterruptedException e) {
       log.warn(e.getStackTrace());
       log.warn(
           "Ha ocurrido una InterruptedException cuando estaba bloqueado el proceso para recuperar el servidor: "
               + servidorCaido.getAddress()
               + " Se continuará la ejecución.");
     } catch (IOException e) {
       log.warn(e.getStackTrace());
       log.warn("El servidor: " + servidorCaido.getAddress() + " continúa lanzando IOException.");
     }
   }
 }
    /** Envoie des VehiculeEvent selon les paramètres (variable p) */
    @Override
    public void run() {
      while (_canRun) {
        if (_vehiculeListener != null) {
          try {
            int tab[] =
                new int[] {
                  _p.nbVoitures + _p.nbBus + _p.nbCamions + _p.nbCaravanes + _p.nbMotos,
                  _p.nbVoitures,
                  _p.nbBus,
                  _p.nbCamions,
                  _p.nbCaravanes,
                  _p.nbMotos
                };

            while (tab[0] != 0 && _vehiculeListener != null) {
              TypeVehicule typeVehicule = TypeVehicule.getRandom();
              VehiculeEvent vehicule =
                  new VehiculeEvent(this, typeVehicule, _numeroVoie, _typeBorne);
              _vehiculeListener.gererVehicule(vehicule);
              Thread.sleep(60000 / _p.flux);
              tab[0]--;
              switch (typeVehicule) {
                case VOITURE:
                  tab[1]--;
                  break;
                case BUS:
                  tab[2]--;
                  break;
                case CAMION:
                  tab[3]--;
                  break;
                case CARAVANE:
                  tab[4]--;
                  break;
                case MOTO:
                  tab[5]--;
                  break;
              }
            }
          } catch (InterruptedException e) {
            e.getStackTrace();
          }
        } else {
          _canRun = false;
        }
      }
    }
Example #6
0
  public void callSendEmailScript(String to, String content, String subjectContext) {
    String subject = constants.getString(subjectContext);
    ResourceBundle scriptsPathConstants = ResourceBundle.getBundle("Scripts");
    File wd = new File(scriptsPathConstants.getString("send_email_path").trim());
    String scriptFileName = scriptsPathConstants.getString("send_project_email").trim();
    String path = wd + File.separator + scriptFileName;
    System.out.println("Script Working Directory: " + path);
    Log.info("Script Working Directory: " + path);

    try {
      // Log.info("Email argument: " + content);
      // System.out.println("Email argument: " + content);
      ProcessBuilder processBuilder = new ProcessBuilder();
      processBuilder.command(path, to, subject, content);
      Process proc = processBuilder.start();
      /* String argument = path + scriptFileName + " \"" + to + "\" \"" + subject + "\" \"" + content + "\"";
      Log.info("Email argument: " + argument);
      System.out.println("Email argument: " + argument);*/
      // proc = Runtime.getRuntime().exec(argument, null);
      // proc = Runtime.getRuntime().exec(argument);
      int exitValue = proc.waitFor();
      Log.info("After executing script: " + path + " exitValue: " + exitValue);
    } catch (InterruptedException e) {
      System.out.println(e.getClass().getName() + ": " + e.getMessage());
      Log.info(e.getClass().getName() + ": " + e.getMessage());
      StackTraceElement[] trace = e.getStackTrace();
      for (int i = 0; i < trace.length; i++) {
        System.out.println("\t" + trace[i].toString());
        Log.info("\n\t" + trace[i].toString());
      }
      e.printStackTrace();
    } catch (Exception e) {
      System.out.println(e.getClass().getName() + ": " + e.getMessage());
      Log.info(e.getClass().getName() + ": " + e.getMessage());
      StackTraceElement[] trace = e.getStackTrace();
      for (int i = 0; i < trace.length; i++) {
        System.out.println("\t" + trace[i].toString());
        Log.info("\n\t" + trace[i].toString());
      }
      e.printStackTrace();
    }
  }
  @Override
  public SampleResult sample(Entry entry) {
    ServiceSocket socket = null;
    SampleResult sampleResult = new SampleResult();
    sampleResult.setSampleLabel(getName());
    sampleResult.setDataEncoding(getContentEncoding());

    StringBuilder errorList = new StringBuilder();
    errorList.append("\n\n[Problems]\n");

    boolean isOK = false;

    String payloadMessage = getRequestPayload();
    sampleResult.setSamplerData(payloadMessage);
    sampleResult.sampleStart();

    try {
      socket = getConnectionSocket();
      if (socket == null) {
        sampleResult.setResponseCode("500");
        sampleResult.setSuccessful(false);
        sampleResult.sampleEnd();
        sampleResult.setResponseMessage(errorList.toString());
        errorList.append(" - Connection couldn't be opened").append("\n");
        return sampleResult;
      }

      if (!payloadMessage.isEmpty()) {
        socket.sendMessage(payloadMessage);
      }

      int responseTimeout = Integer.parseInt(getResponseTimeout());
      socket.awaitClose(responseTimeout, TimeUnit.MILLISECONDS);

      if (socket.getResponseMessage() == null || socket.getResponseMessage().isEmpty()) {
        sampleResult.setResponseCode("204");
      }

      if (socket.getError() != 0) {
        isOK = false;
        sampleResult.setResponseCode(socket.getError().toString());
      } else {
        sampleResult.setResponseCodeOK();
        isOK = true;
      }

      sampleResult.setResponseData(socket.getResponseMessage(), getContentEncoding());

    } catch (URISyntaxException e) {
      errorList
          .append(" - Invalid URI syntax: ")
          .append(e.getMessage())
          .append("\n")
          .append(StringUtils.join(e.getStackTrace(), "\n"))
          .append("\n");
    } catch (IOException e) {
      errorList
          .append(" - IO Exception: ")
          .append(e.getMessage())
          .append("\n")
          .append(StringUtils.join(e.getStackTrace(), "\n"))
          .append("\n");
    } catch (NumberFormatException e) {
      errorList
          .append(" - Cannot parse number: ")
          .append(e.getMessage())
          .append("\n")
          .append(StringUtils.join(e.getStackTrace(), "\n"))
          .append("\n");
    } catch (InterruptedException e) {
      errorList
          .append(" - Execution interrupted: ")
          .append(e.getMessage())
          .append("\n")
          .append(StringUtils.join(e.getStackTrace(), "\n"))
          .append("\n");
    } catch (Exception e) {
      errorList
          .append(" - Unexpected error: ")
          .append(e.getMessage())
          .append("\n")
          .append(StringUtils.join(e.getStackTrace(), "\n"))
          .append("\n");
    }

    sampleResult.sampleEnd();
    sampleResult.setSuccessful(isOK);

    String logMessage = (socket != null) ? socket.getLogMessage() : "";
    sampleResult.setResponseMessage(logMessage + errorList);
    return sampleResult;
  }