Examples with Log org.neo4j.logging.Log used on opensource projects

Example 91 with Log

use of org.neo4j.logging.Log in project neo4j by neo4j.

the class ServerConfigurationValidator method validate.

/**
     * Verifies that at least one http connector is specified and enabled.
     */
@Override
@Nonnull
public Map<String, String> validate(@Nonnull Collection<SettingValidator> settingValidators, @Nonnull Map<String, String> rawConfig, @Nonnull Log log, boolean parsingFile) throws InvalidSettingException {
    Pattern pattern = Pattern.compile(Pattern.quote("dbms.connector.") + "([^\\.]+)\\.(.+)");
    List<Connector> connectors = rawConfig.keySet().stream().map(pattern::matcher).filter(Matcher::matches).map(match -> match.group(1)).distinct().map(Connector::new).collect(Collectors.toList());
    Map<String, String> validSettings = new HashMap<>(rawConfig);
    // Add missing type info -- validation has succeeded so we can do this with confidence
    connectors.stream().filter(connector -> connector.type.apply(rawConfig::get) == null).forEach(connector -> {
        if ("http".equalsIgnoreCase(connector.group.groupKey) || "https".equalsIgnoreCase(connector.group.groupKey)) {
            validSettings.put(connector.type.name(), HTTP.name());
        } else {
            validSettings.put(connector.type.name(), BOLT.name());
        }
    });
    if (connectors.stream().filter(connector -> connector.type.apply(validSettings::get).equals(HTTP)).noneMatch(connector -> connector.enabled.apply(validSettings::get))) {
        throw new InvalidSettingException(String.format("Missing mandatory enabled connector of type '%s'", HTTP));
    }
    return validSettings;
}

Example 92 with Log

use of org.neo4j.logging.Log in project neo4j by neo4j.

the class DataSourceModule method setupProcedures.

private Procedures setupProcedures(PlatformModule platform, EditionModule editionModule) {
    File pluginDir = platform.config.get(GraphDatabaseSettings.plugin_dir);
    Log internalLog = platform.logging.getInternalLog(Procedures.class);
    Procedures procedures = new Procedures(new SpecialBuiltInProcedures(Version.getNeo4jVersion(), platform.databaseInfo.edition.toString()), pluginDir, internalLog, new ProcedureConfig(platform.config));
    platform.life.add(procedures);
    platform.dependencies.satisfyDependency(procedures);
    procedures.registerType(Node.class, new SimpleConverter(NTNode, Node.class));
    procedures.registerType(Relationship.class, new SimpleConverter(NTRelationship, Relationship.class));
    procedures.registerType(Path.class, new SimpleConverter(NTPath, Path.class));
    procedures.registerType(Geometry.class, new SimpleConverter(NTGeometry, Geometry.class));
    procedures.registerType(Point.class, new SimpleConverter(NTPoint, Point.class));
    // Register injected public API components
    Log proceduresLog = platform.logging.getUserLog(Procedures.class);
    procedures.registerComponent(Log.class, (ctx) -> proceduresLog, true);
    Guard guard = platform.dependencies.resolveDependency(Guard.class);
    procedures.registerComponent(ProcedureTransaction.class, new ProcedureTransactionProvider(), true);
    procedures.registerComponent(TerminationGuard.class, new TerminationGuardProvider(guard), true);
    // Below components are not public API, but are made available for internal
    // procedures to call, and to provide temporary workarounds for the following
    // patterns:
    //  - Batch-transaction imports (GDAPI, needs to be real and passed to background processing threads)
    //  - Group-transaction writes (same pattern as above, but rather than splitting large transactions,
    //                              combine lots of small ones)
    //  - Bleeding-edge performance (KernelTransaction, to bypass overhead of working with Core API)
    procedures.registerComponent(DependencyResolver.class, (ctx) -> platform.dependencies, false);
    procedures.registerComponent(KernelTransaction.class, (ctx) -> ctx.get(KERNEL_TRANSACTION), false);
    procedures.registerComponent(GraphDatabaseAPI.class, (ctx) -> platform.graphDatabaseFacade, false);
    // Security procedures
    procedures.registerComponent(SecurityContext.class, ctx -> ctx.get(SECURITY_CONTEXT), true);
    // Edition procedures
    try {
        editionModule.registerProcedures(procedures);
    } catch (KernelException e) {
        internalLog.error("Failed to register built-in edition procedures at start up: " + e.getMessage());
    }
    return procedures;
}

Example 93 with Log

use of org.neo4j.logging.Log in project neo4j by neo4j.

the class NeoStores method createCountStore.

CountsTracker createCountStore(String storeName) {
    File storeFile = getStoreFile(storeName);
    boolean readOnly = config.get(GraphDatabaseSettings.read_only);
    CountsTracker counts = readOnly ? createReadOnlyCountsTracker(storeFile) : createWritableCountsTracker(storeFile);
    NeoStores neoStores = this;
    counts.setInitializer(new DataInitializer<CountsAccessor.Updater>() {

        private final Log log = logProvider.getLog(MetaDataStore.class);

        @Override
        public void initialize(CountsAccessor.Updater updater) {
            log.warn("Missing counts store, rebuilding it.");
            new CountsComputer(neoStores).initialize(updater);
        }

        @Override
        public long initialVersion() {
            return ((MetaDataStore) getOrCreateStore(StoreType.META_DATA)).getLastCommittedTransactionId();
        }
    });
    try {
        // TODO: move this to LifeCycle
        counts.init();
    } catch (IOException e) {
        throw new UnderlyingStorageException("Failed to initialize counts store", e);
    }
    return counts;
}

Example 94 with Log

use of org.neo4j.logging.Log in project neo4j by neo4j.

the class ConsistencyCheckService method runFullConsistencyCheck.

public Result runFullConsistencyCheck(File storeDir, Config config, ProgressMonitorFactory progressFactory, LogProvider logProvider, FileSystemAbstraction fileSystem, boolean verbose, File reportDir, CheckConsistencyConfig checkConsistencyConfig) throws ConsistencyCheckIncompleteException, IOException {
    Log log = logProvider.getLog(getClass());
    ConfiguringPageCacheFactory pageCacheFactory = new ConfiguringPageCacheFactory(fileSystem, config, PageCacheTracer.NULL, PageCursorTracerSupplier.NULL, logProvider.getLog(PageCache.class));
    PageCache pageCache = pageCacheFactory.getOrCreatePageCache();
    try {
        return runFullConsistencyCheck(storeDir, config, progressFactory, logProvider, fileSystem, pageCache, verbose, reportDir, checkConsistencyConfig);
    } finally {
        try {
            pageCache.close();
        } catch (Exception e) {
            log.error("Failure during shutdown of the page cache", e);
        }
    }
}

Example 95 with Log

use of org.neo4j.logging.Log in project neo4j by neo4j.

the class BackupServiceIT method shouldPrintThatFullBackupIsPerformed.

@Test
public void shouldPrintThatFullBackupIsPerformed() throws Exception {
    defaultBackupPortHostParams();
    GraphDatabaseService db = dbRule.getGraphDatabaseAPI();
    final Log log = mock(Log.class);
    LogProvider logProvider = new LogProvider() {

        @Override
        public Log getLog(Class loggingClass) {
            return log;
        }

        @Override
        public Log getLog(String name) {
            return log;
        }
    };
    backupService(logProvider).doIncrementalBackupOrFallbackToFull(BACKUP_HOST, backupPort, backupDir, ConsistencyCheck.NONE, dbRule.getConfigCopy(), BackupClient.BIG_READ_TIMEOUT, false);
    verify(log).info("Previous backup not found, a new full backup will be performed.");
}