How to use

line

method

in

sirius.kernel.health.console.Command$Output

private void outputMappingRow(Output output, Map.Entry<String, Object> e) {
  if (e.getValue() instanceof Map) {
    output.line(e.getKey());
    for (Map.Entry<?, ?> subEntry : ((Map<?, ?>) e.getValue()).entrySet()) {
      output.line("   " + subEntry.getKey() + ": " + subEntry.getValue());
    }
  } else {
    output.line(e.getKey() + ": " + e.getValue());
  }
}

private void parseParameters(Output output, String param) {
  if ("enable".equalsIgnoreCase(param) || "+".equalsIgnoreCase(param)) {
    enableTiming(output);
  } else if ("disable".equalsIgnoreCase(param) || "-".equalsIgnoreCase(param)) {
    disableTiming(output);
  } else {
    output.line("Usage: timing enable|disable (You can use + and - for enable/disable).");
    output.line("To enable tracing: timing trace <filter-expression>");
  }
}

@Override
public void execute(Output output, String... params) throws Exception {
  if (params.length < 1) {
    output.line("Usage: md5 <input>");
  } else {
    output.line("Input: " + params[0]);
    output.line("Timestamp: " + System.currentTimeMillis() / 1000);
    output.line("MD5: " + Hashing.md5().hashString(params[0], Charsets.UTF_8).toString());
  }
}

@Override
public void execute(Output output, String... params) throws Exception {
  Values values = Values.of(params);
  if ("query".equalsIgnoreCase(values.at(0).asString())) {
    query(output, values);
  } else if ("update".equalsIgnoreCase(values.at(0).asString())) {
    update(output, values);
  } else if ("delete".equalsIgnoreCase(values.at(0).asString())) {
    delete(output, values);
  } else if ("resave".equalsIgnoreCase(values.at(0).asString())) {
    resave(output, values);
  } else if ("unbalance".equalsIgnoreCase(values.at(0).asString())) {
    unbalance(output);
  } else if ("balance".equalsIgnoreCase(values.at(0).asString())) {
    balance(output);
  } else {
    output.apply("Unknown command: %s", values.at(0));
    output.line("Use: query <type> <filter>");
    output.line(" or update <type> <filter> <field> <value> (Limit 500)");
    output.line(" or delete <type> <filter>");
    output.line(" or resave <type> <filter>");
    output.line(" or unbalance");
    output.line(" or balance");
  }
}

private void outputMapping(Output output, String name) {
  Class<? extends Entity> type = index.getType(name);
  EntityDescriptor ed = index.getDescriptor(type);
  GetMappingsResponse res = index.getClient()
                  .admin()
                  .indices()
                  .prepareGetMappings(index.getIndexName(ed.getIndex()))
                  .setTypes(ed.getType())
                  .execute()
                  .actionGet();
  try {
    ByteArrayOutputStream out = new ByteArrayOutputStream();
    output.blankLine();
    output.line(name);
    output.separator();
    Iterator<ImmutableOpenMap<String, MappingMetaData>> outerIter = res.mappings().valuesIt();
    while (outerIter.hasNext()) {
      ImmutableOpenMap<String, MappingMetaData> c = outerIter.next();
      outputMapping(output, c);
    }
    output.line(new String(out.toByteArray(), Charsets.UTF_8));
  } catch (IOException e) {
    output.line(Exceptions.handle(e).getMessage());
  }
}

@Override
public void execute(Output output, String... params) throws Exception {
  Value name = Value.indexOf(0, params);
  if (name.isEmptyString()) {
    output.line("No class name given. Try: doc <classname>");
    return;
  }
  Injector.getAllLoadedClasses()
      .stream()
      .filter(c -> c.getName().toLowerCase().contains(name.asString().toLowerCase()))
      .forEach(c -> {
        output.line(c.getName());
        output.separator();
        for (Method m : c.getMethods()) {
          output.line(m.toString());
        }
        output.blankLine();
      });
}

@Override
public void execute(Output output, String... params) {
  if (params.length > 0) {
    for (Cache<?, ?> c : CacheManager.getCaches()) {
      if (Value.indexOf(0, params).asString().equals(c.getName())) {
        output.apply("Flushing: %s", params[0]);
        c.clear();
      }
    }
  } else {
    output.line("Use cache <name> to flush the given cache...");
  }
  output.blankLine();
  output.apply("%-53s %8s %8s %8s", "NAME", "SIZE", "MAX-SIZE", "HIT-RATE");
  output.separator();
  for (Cache<?, ?> c : CacheManager.getCaches()) {
    output.apply("%-53s %8d %8d %8d", c.getName(), c.getSize(), c.getMaxSize(), c.getHitRate());
  }
  output.separator();
}

@Override
public void execute(Output output, String... params) throws Exception {
  boolean withTraces = Value.indexOf(0, params).isFilled();
  boolean includeWaiting = "Y".equals(Value.indexOf(1, params).asString());
  if (withTraces) {
    outputThreadInfos(output, includeWaiting, params[0]);
  } else {
    output.line("Usage: threads [<filter> (or 'all')] [Y=include WAITING/NATIVE]");
    output.separator();
    output.apply("%-15s %10s %53s", "STATE", "ID", "NAME");
    output.separator();
    for (ThreadInfo info : t.dumpAllThreads(false, false)) {
      output.apply("%-15s %10s %53s",
             info.isInNative() ? "NATIVE" : info.getThreadState().name(),
             info.getThreadId(),
             info.getThreadName());
    }
    output.separator();
  }
}

private void query(Output output, Values values) {
  Class<? extends Entity> type = UpdateMappingCommand.findTypeOrReportError(output, values.at(1).asString());
  if (type != null) {
    output.line("Results (limited at 500):");
    output.separator();
    AtomicInteger rows = new AtomicInteger();
    for (Entity e : index.select(type)
               .deliberatelyUnrouted()
               .query(values.at(2).asString())
               .limit(500)
               .queryList()) {
      output.line(e.toDebugString());
      rows.incrementAndGet();
    }
    outputAffectedRows(output, rows);
  }
}

@Override
public void execute(Output output, String... params) throws Exception {
  if (Value.indexOf(0, params).isEmptyString()) {
    output.line("Usage: updateMapping <type>");
  } else {
    Class<? extends Entity> type = findTypeOrReportError(output, params[0]);
    if (type != null) {
      EntityDescriptor ed = index.getDescriptor(type);
      try {
        index.addMapping(index.getIndexName(ed.getIndex()), type);
        output.line("Mapping was updated...");
      } catch (Exception e) {
        output.line(e.getMessage());
        output.line("If necessary use the force option but be aware that there might be data loss!");
      }
    }
  }
}

@Override
public void execute(Output output, String... params) {
  if (params.length == 2) {
    output.apply("Setting %s to: %s", params[0], params[1]);
    Log.setLevel(params[0], Level.toLevel(params[1]));
    output.blankLine();
  } else {
    output.line("Usage: logger <name> <LEVEL>");
    output.blankLine();
    output.line("Known loggers:");
    output.separator();
    for (Log l : Log.getAllLoggers()) {
      output.line(l.getName());
    }
    output.separator();
  }
}

@Override
public void execute(Output output, String... params) throws Exception {
  output.line(Product.getProduct().toString());
  output.blankLine();
  output.line("MODULES");
  output.separator();
  output.blankLine();
  Product.getModules().forEach(m -> {
    output.line(m.getName());
    output.line(m.getDetails());
    output.blankLine();
  });
  output.separator();
}

private void outputMapping(Output output, ImmutableOpenMap<String, MappingMetaData> c) throws IOException {
  Iterator<String> iter = c.keysIt();
  while (iter.hasNext()) {
    String property = iter.next();
    MappingMetaData md = c.get(property);
    output.line("routing: " + md.routing().toString());
    for (Map.Entry<String, Object> e : md.getSourceAsMap().entrySet()) {
      outputMappingRow(output, e);
    }
  }
}

private void disableTiming(Output output) {
  generateOutput(output);
  Microtiming.setEnabled(false);
  output.line("Disabling Microtiming...");
}

private static void reportUnknownType(Output output, String typeName) {
  output.line("Unknown type: " + typeName);
  Monoflop mf = Monoflop.create();
  for (String name : index.getSchema().getTypeNames()) {
    if (name.toLowerCase().contains(typeName.toLowerCase())) {
      if (mf.firstCall()) {
        output.line("Did you mean one of those: ");
      }
      output.line(" * " + name);
    }
  }
}

private void balance(Output output) {
  output.line("Enabling automatic allocation.");
  changeAllocationMode("all");
  output.line("Enabled automatic allocation.");
  output.blankLine();
}

private void unbalance(Output output) {
  output.line("Disabling automatic allocation.");
  changeAllocationMode("none");
  output.line("Disabled automatic allocation.");
  output.blankLine();
}

@Override
public void execute(Output output, String... params) throws Exception {
  if (params.length == 1 && Strings.isFilled(params[0])) {
    parseParameters(output, params[0]);
  } else {
    if (Microtiming.isEnabled()) {
      generateOutput(output);
    } else {
      output.line("Microtiming is disabled! Use: 'timing +' to enable.");
    }
  }
}

private void enableTiming(Output output) {
  if (Microtiming.isEnabled()) {
    generateOutput(output);
    Microtiming.setEnabled(false);
    output.line("Resetting Microtiming...");
  } else {
    output.line("Enabling Microtiming...");
  }
  Microtiming.setEnabled(true);
}

@Override
public void execute(Output output, String... params) throws Exception {
  if (params.length != 1) {
    output.line("Usage: reindex <newIndexPrefix>");
  } else {
    index.getSchema().reIndex(params[0]);
    output.line("Operation has started!");
  }
}