Java Log.error方法代码示例

import jline.internal.Log; //导入方法依赖的package包/类
public Object eval(ScriptObject o, Object scope, String source, boolean returnStuff) {
    if (!Settings.instance().getLocalMode()) {
        Log.error("You can only call 'eval' in local mode");
        return "";
    }
    try {
        //new jdk.nashorn.internal.runtime.DebugLogger().
        Class<?> c = Class.forName("jdk.nashorn.internal.runtime.DebuggerSupport");//full package name
        //note: getConstructor() can return only public constructors,
        //you need to use

        Method method = c.getDeclaredMethod("eval", ScriptObject.class, Object.class, String.class, boolean.class);

        //Constructor<?> constructor = c.getDeclaredConstructor();
        method.setAccessible(true);
        return method.invoke(null, o, scope, source, returnStuff);
    } catch (Exception e) {
        Log.error(e);
        return null;
    }
}
 

import jline.internal.Log; //导入方法依赖的package包/类
private Object getDebugSupport() {


        //return new NashornDebugHelper();
        try {
            Class<?> c = Class.forName("jdk.nashorn.internal.runtime.DebuggerSupport");//full package name
            //note: getConstructor() can return only public constructors,
            //you need to use
            Method method = c.getDeclaredMethod("eval", ScriptObject.class, Object.class, String.class, boolean.class);

            //Constructor<?> constructor = c.getDeclaredConstructor();
            method.setAccessible(true);
            return method;
            //constructor.setAccessible(true);
            //Object o = constructor.newInstance(null);
            //return o;
        } catch (Exception e) {
            Log.error(e);
            return null;
        }
    }
 

import jline.internal.Log; //导入方法依赖的package包/类
@Override
public synchronized void setEchoEnabled(final boolean enabled) {
    try {
        if (enabled) {
            settings.set("echo");
        }
        else {
            settings.set("-echo");
        }
        super.setEchoEnabled(enabled);
    }
    catch (Exception e) {
        if (e instanceof InterruptedException) {
            Thread.currentThread().interrupt();
        }
        Log.error("Failed to ", (enabled ? "enable" : "disable"), " echo", e);
    }
}
 

import jline.internal.Log; //导入方法依赖的package包/类
public String getInput(String prompt) throws Exception {
    if (!Settings.instance().getLocalMode()) {
        Log.error("You can only call 'getInput' in local mode");
        return "";
    }

    ConsoleReader reader = new ConsoleReader();
    return reader.readLine(prompt);
}
 

import jline.internal.Log; //导入方法依赖的package包/类
public Object inspect(Object object) throws Exception {
    if (!Settings.instance().getLocalMode()) {
        Log.error("You can only call 'inspect' in local mode");
        return "";
    }
    Class<?> c = Class.forName("jdk.nashorn.internal.runtime.DebuggerSupport");//full package name
    //note: getConstructor() can return only public constructors,
    //you need to use

    Method method = c.getDeclaredMethod("valueInfos", Object.class, boolean.class);
    //valueInfos(Object object, boolean all)
    //Constructor<?> constructor = c.getDeclaredConstructor();
    method.setAccessible(true);
    Object[] objects = (Object[])method.invoke(null, object, true);
    //List<Map> returnObjects = new ArrayList<>();
    Map desc = new HashMap<>();
    for(Object o: objects) {
        Map map = new HashMap<>();

        Field field = o.getClass().getDeclaredField("key");
        field.setAccessible(true);
        Object key = field.get(o);

        Field field2 = o.getClass().getDeclaredField("valueAsString");
        field2.setAccessible(true);
        Object val = field2.get(o);
        desc.put(key.toString(), val.toString());

    }
    return desc;
}
 

import jline.internal.Log; //导入方法依赖的package包/类
protected String createUrlPath(int timeoutMs, int limit) {
	final StringBuilder url = new StringBuilder(CambriaPublisherUtility.makeConsumerUrl(fTopic, fGroup, fId));
	final StringBuilder adds = new StringBuilder();
	if (timeoutMs > -1) {
		adds.append("timeout=").append(timeoutMs);
	}

	if (limit > -1) {
		if (adds.length() > 0) {
			adds.append("&");
		}
		adds.append("limit=").append(limit);
	}
	if (fFilter != null && fFilter.length() > 0) {
		try {
			if (adds.length() > 0) {
				adds.append("&");
			}
			adds.append("filter=").append(URLEncoder.encode(fFilter, "UTF-8"));
		} catch (UnsupportedEncodingException e) {
			Log.error("Failed due to UnsupportedEncodingException" + e);
		}
	}
	if (adds.length() > 0) {
		url.append("?").append(adds.toString());
	}
	return url.toString();
}
 

import jline.internal.Log; //导入方法依赖的package包/类
public static void syncConfig() {
    try {
        processConfig();
    } catch (Exception e) {
        Log.error(MODID + " has a problem loading its configuration!");
        e.printStackTrace();
    } finally {
        if(config.hasChanged()) {
            config.save();
        }
    }
}
 

import jline.internal.Log; //导入方法依赖的package包/类
/**
 * Clear the buffer and add its contents to the history.
 *
 * @return the former contents of the buffer.
 */
final String finishBuffer() throws IOException { // FIXME: Package protected because used by tests
    String str = buf.buffer.toString();
    String historyLine = str;

    if (expandEvents) {
        try {
            str = expandEvents(str);
            // all post-expansion occurrences of '!' must have been escaped, so re-add escape to each
            historyLine = str.replace("!", "\\!");
            // only leading '^' results in expansion, so only re-add escape for that case
            historyLine = historyLine.replaceAll("^\\^", "\\\\^");
        } catch(IllegalArgumentException e) {
            Log.error("Could not expand event", e);
            beep();
            buf.clear();
            str = "";
        }
    }

    // we only add it to the history if the buffer is not empty
    // and if mask is null, since having a mask typically means
    // the string was a password. We clear the mask after this call
    if (str.length() > 0) {
        if (mask == null && isHistoryEnabled()) {
            history.add(historyLine);
        }
        else {
            mask = null;
        }
    }

    history.moveToEnd();

    buf.buffer.setLength(0);
    buf.cursor = 0;

    return str;
}
 

import jline.internal.Log; //导入方法依赖的package包/类
public void disableInterruptCharacter()
{
    try {
        settings.set("intr undef");
    }
    catch (Exception e) {
        if (e instanceof InterruptedException) {
            Thread.currentThread().interrupt();
        }
        Log.error("Failed to disable interrupt character", e);
    }
}
 

import jline.internal.Log; //导入方法依赖的package包/类
public void enableInterruptCharacter()
{
    try {
        settings.set("intr ^C");
    }
    catch (Exception e) {
        if (e instanceof InterruptedException) {
            Thread.currentThread().interrupt();
        }
        Log.error("Failed to enable interrupt character", e);
    }
}
 

import jline.internal.Log; //导入方法依赖的package包/类
@Override
public boolean isRunning() {
    if (runner == null)
        return false;
    
    try {
        return CassandraRunner.waitForPortOpen(InetAddress.getByName("localhost"), Integer.parseInt(default_native_transport_port), 2000);
    } catch (UnknownHostException e) {
        Log.error("Cassandra failed to start: ", e);
        return false;
    }
}
 

import jline.internal.Log; //导入方法依赖的package包/类
@Override
public void shutdown() {
    if (null != provider) {
        try {
            runtime.unregisterProvider(localDomain, provider);
        } catch (JoynrRuntimeException exception) {
            Log.error("Failed to unregister provider", exception);
        }
    }

    runtime.shutdown(true);
    System.exit(0);
}
 

import jline.internal.Log; //导入方法依赖的package包/类
@Override
public void run() {
    EchoProxy echoProxy = createEchoProxy();

    if (invocationParameters.getCommunicationMode() == COMMUNICATIONMODE.SYNC) {
        switch (invocationParameters.getTestCase()) {
        case SEND_STRING:
            performSyncSendStringTest(echoProxy);
            break;
        case SEND_STRUCT:
            performSyncSendStructTest(echoProxy);
            break;
        case SEND_BYTEARRAY:
            performSyncSendByteArrayTest(echoProxy);
            break;
        default:
            Log.error("Unknown test type used");
            break;
        }
    } else if (invocationParameters.getCommunicationMode() == COMMUNICATIONMODE.ASYNC) {
        switch (invocationParameters.getTestCase()) {
        case SEND_STRING:
            performAsyncSendStringTest(echoProxy);
            break;
        case SEND_STRUCT:
            performAsyncSendStructTest(echoProxy);
            break;
        case SEND_BYTEARRAY:
            performAsyncSendByteArrayTest(echoProxy);
            break;
        default:
            Log.error("Unknown test type used");
            break;
        }
    } else {
        Log.error("Unknown communication mode used");
    }
}
 

import jline.internal.Log; //导入方法依赖的package包/类
/**
 * Start the ssh daemon.
 */
public void start() {
    final String portString = System.getProperty(COMMANDER_SSH_PORT);
    if (portString == null) {
        Log.warn("No 'commander.ssh.port' specified, ssh support will not be enabled!");
        return;
    }

    int port;
    try {
        port = Integer.parseInt(portString);
    } catch (NumberFormatException ex) {
        Log.error("Bad port '" + portString + "' specified, ssh support will not be enabled!");
        return;
    }

    final String username = System.getProperty(COMMANDER_SSH_USERNAME);
    if (username == null) {
        Log.warn("No 'commander.ssh.username' specified, ssh support will not be enabled!");
        return;
    }

    final String password = System.getProperty(COMMANDER_SSH_PASSWORD);
    if (password == null) {
        Log.warn("No 'commander.ssh.password' specified, ssh support will not be enabled!");
        return;
    }

    this.sshd = SshServer.setUpDefaultServer();
    sshd.setPasswordAuthenticator(new PasswordAuthenticator() {
        @Override
        public boolean authenticate(@Nullable String u, @Nullable String p, ServerSession serverSession) {
            if (p == null || u == null) {
                return false;
            }
            return MessageDigest.isEqual(username.getBytes(StandardCharsets.UTF_8), u.getBytes(StandardCharsets.UTF_8))
                    && MessageDigest.isEqual(password.getBytes(StandardCharsets.UTF_8), p.getBytes(StandardCharsets.UTF_8));
        }
    });
    sshd.setKeyPairProvider(new SimpleGeneratorHostKeyProvider("hostkey.ser"));


    sshd.setPort(port);

    sshd.setShellFactory(new CommanderSshCommandFactory());

    try {
        sshd.start();
        Log.info("Ssh support started on port " + port);
    } catch (IOException e) {
        Log.error("Couldn't start the ssh daemon", e);
    }
}