示例#1
0
  public EMSMongoClient() throws IOException {
    Properties config = new Properties();

    InputStream in = this.getClass().getClassLoader().getResourceAsStream("config.properties");

    config.load(in);

    MongoClient client;

    List<ServerAddress> serverAddresses =
        Arrays.asList(
            new ServerAddress(
                config.getProperty("mongo_host"),
                Integer.parseInt(config.getProperty("mongo_port"))));

    if (config.containsKey("mongo_user") && config.containsKey("mongo_password")) {
      MongoCredential credential =
          MongoCredential.createMongoCRCredential(
              config.getProperty("mongo_user"),
              config.getProperty("mongo_db"),
              config.getProperty("mongo_password").toCharArray());

      client = new MongoClient(serverAddresses, Arrays.asList(credential));
    } else {
      client = new MongoClient(serverAddresses);
    }

    DB db = client.getDB(config.getProperty("mongo_db"));

    this.collection = db.getCollection("sessions");
  }
示例#2
0
  public static void main(String[] args) {

    System.setProperty("javax.net.ssl.trustStore", args[0]);
    System.setProperty("javax.net.ssl.trustStorePassword", args[1]);
    MongoClientOptions.Builder options = builder().sslEnabled(true).sslInvalidHostNameAllowed(true);
    String uri = "mongodb://127.0.0.1:27017/";
    MongoClientURI connectionString = new MongoClientURI(uri, options);
    MongoClient mongoClient = new MongoClient(connectionString);

    // with username and password

    char[] pwd = "mypasswrd!".toCharArray();

    MongoCredential credential =
        MongoCredential.createCredential(
            "myadmin", "admin", pwd); // user "myadmin" on admin database

    List<MongoCredential> credentials = Collections.singletonList(credential);

    List<ServerAddress> hosts =
        Arrays.asList(
            new ServerAddress("mongodb01.host.dblayer.com:10054"),
            new ServerAddress("mongodb02.host.1.dblayer.com:10071"));

    mongoClient = new MongoClient(hosts, credentials, options.build());
    MongoDatabase foxtrot = mongoClient.getDatabase("foxtrot");
    MongoIterable<String> collectionNames = foxtrot.listCollectionNames();
  }
 /**
  * Creates a {@link MongoClient} using the given {@code options} and {@code environment}. If the
  * configured port is zero, the value of the {@code local.mongo.port} property retrieved from the
  * {@code environment} is used to configure the client.
  *
  * @param options the options
  * @param environment the environment
  * @return the Mongo client
  * @throws UnknownHostException if the configured host is unknown
  */
 public MongoClient createMongoClient(MongoClientOptions options, Environment environment)
     throws UnknownHostException {
   try {
     if (hasCustomAddress() || hasCustomCredentials()) {
       if (options == null) {
         options = MongoClientOptions.builder().build();
       }
       List<MongoCredential> credentials = null;
       if (hasCustomCredentials()) {
         String database =
             this.authenticationDatabase == null
                 ? getMongoClientDatabase()
                 : this.authenticationDatabase;
         credentials =
             Arrays.asList(
                 MongoCredential.createMongoCRCredential(this.username, database, this.password));
       }
       String host = this.host == null ? "localhost" : this.host;
       int port = determinePort(environment);
       return new MongoClient(Arrays.asList(new ServerAddress(host, port)), credentials, options);
     }
     // The options and credentials are in the URI
     return new MongoClient(new MongoClientURI(this.uri, builder(options)));
   } finally {
     clearPassword();
   }
 }
示例#4
0
  @Override
  public void onEnable() {
    instance = this;

    Bukkit.getPluginManager().registerEvents(new PlayerJoinListener(), this);
    Bukkit.getPluginManager().registerEvents(new PlayerQuitListener(), this);
    Bukkit.getPluginManager().registerEvents(new InventoryClickListener(), this);
    Bukkit.getPluginManager().registerEvents(new InventoryCloseListener(), this);
    Bukkit.getPluginManager().registerEvents(new PlayerInteractListener(), this);

    mongoClient =
        new MongoClient(
            new ServerAddress("craplezz.de", 27017),
            Collections.singletonList(
                MongoCredential.createCredential(
                    "Overload", "admin", "1999mani123".toCharArray())));
    localeManager = new LocaleManager(mongoClient, "todo", "general");
    serverManager =
        new ServerManager(
            new CachedServerInfo(
                getServer().getServerName(),
                getServer().getMaxPlayers(),
                getServer().getOnlinePlayers().size(),
                getServer().getMotd()));

    getServer().getMessenger().registerOutgoingPluginChannel(this, "BungeeCord");

    // Broadcast own server info
    serverManager.broadcastServerInfoData();
  }
示例#5
0
文件: AppConfig.java 项目: imxood/app
  /**
   * 配置MongoDB的Bean
   *
   * @return
   * @throws Exception
   */
  public @Bean MongoDbFactory mongoDbFactory() throws Exception {

    List<MongoCredential> credentialsList = new ArrayList<MongoCredential>();
    MongoCredential userCredentials =
        MongoCredential.createCredential(user, authenticationDatabase, password.toCharArray());
    credentialsList.add(userCredentials);
    return new SimpleMongoDbFactory(
        new MongoClient(new ServerAddress(host, port), credentialsList), database);
  }
  public MongoConnector() {
    if (Constants.Mongo.AUTH_ENABLED) {
      mongoCredential =
          MongoCredential.createCredential(
              Constants.Mongo.USER, Constants.Mongo.DATABASE, Constants.Mongo.USER_PASS);
    }

    mongoServerAddress = new ServerAddress(Constants.Mongo.HOST, Constants.Mongo.PORT);

    this.mongoClient = new MongoClient(mongoServerAddress, Arrays.asList(mongoCredential));
  }
  private MongoCredential createCredentials(
      Map<String, List<String>> optionsMap,
      final String userName,
      final char[] password,
      String database) {
    if (userName == null) {
      return null;
    }

    if (database == null) {
      database = "admin";
    }

    String mechanism = MongoCredential.MONGODB_CR_MECHANISM;
    String authSource = database;
    String gssapiServiceName = null;

    for (String key : authKeys) {
      String value = getLastValue(optionsMap, key);

      if (value == null) {
        continue;
      }

      if (key.equals("authmechanism")) {
        mechanism = value;
      } else if (key.equals("authsource")) {
        authSource = value;
      } else if (key.equals("gssapiservicename")) {
        gssapiServiceName = value;
      }
    }

    if (mechanism.equals(MongoCredential.GSSAPI_MECHANISM)) {
      MongoCredential gssapiCredential = MongoCredential.createGSSAPICredential(userName);
      if (gssapiServiceName != null) {
        gssapiCredential =
            gssapiCredential.withMechanismProperty("SERVICE_NAME", gssapiServiceName);
      }
      return gssapiCredential;
    } else if (mechanism.equals(MongoCredential.PLAIN_MECHANISM)) {
      return MongoCredential.createPlainCredential(userName, authSource, password);
    } else if (mechanism.equals(MongoCredential.MONGODB_CR_MECHANISM)) {
      return MongoCredential.createMongoCRCredential(userName, authSource, password);
    } else if (mechanism.equals(MongoCredential.MONGODB_X509_MECHANISM)) {
      return MongoCredential.createMongoX509Credential(userName);
    } else if (mechanism.equals(MongoCredential.SCRAM_SHA_1_MECHANISM)) {
      return MongoCredential.createScramSha1Credential(userName, authSource, password);
    } else {
      throw new IllegalArgumentException("Unsupported authMechanism: " + mechanism);
    }
  }
  @Override
  @Bean
  public Mongo mongo() throws Exception {
    host = System.getenv("CU_DATABASE_DNS_MONGO_1");
    port = 27017;
    username = System.getenv("CU_DATABASE_USER_MONGO_1");
    database = System.getenv("CU_DATABASE_NAME");
    password = System.getenv("CU_DATABASE_PASSWORD_MONGO_1");

    log.info("CU_DATABASE_DNS_MONGO_1 : " + host);
    log.info("CU_DATABASE_USER_MONGO_1 : " + username);
    log.info("CU_DATABASE_NAME : " + database);
    log.info("CU_DATABASE_PASSWORD_MONGO_1 : " + password);

    log.info("MongoDB Initialization");
    return new MongoClient(
        singletonList(new ServerAddress(host, port)),
        singletonList(MongoCredential.createCredential(username, "admin", password.toCharArray())));
  }
示例#9
0
  private CommandResultPair authenticateCommandHelper(String username, char[] password) {
    MongoCredential credentials =
        MongoCredential.createMongoCRCredential(username, getName(), password);
    if (getAuthenticationCredentials() != null) {
      if (getAuthenticationCredentials().equals(credentials)) {
        if (authenticationTestCommandResult != null) {
          return new CommandResultPair(authenticationTestCommandResult);
        }
      } else {
        throw new IllegalStateException("can't authenticate twice on the same database");
      }
    }

    try {
      authenticationTestCommandResult = doAuthenticate(credentials);
      return new CommandResultPair(authenticationTestCommandResult);
    } catch (CommandFailureException commandFailureException) {
      return new CommandResultPair(commandFailureException);
    }
  }
  protected MongoClient createMongoClient(Collection<String> uris, MongoClientOptions options) {
    String currentURI = null;

    try {
      List<ServerAddress> serverAddresses = new ArrayList<>(uris.size());
      List<MongoCredential> mongoCredentials = new ArrayList<>();

      for (String uri : uris) {
        currentURI = uri;
        serverAddresses.add(createServerAddress(currentURI));
        String[] segments = currentURI.split("/");
        String host = segments[2];
        int authIndex = host.indexOf('@');

        if (segments.length == 4) databaseName = segments[3];

        if (authIndex > 0) {
          String[] credentials = host.substring(0, authIndex).split(":");
          mongoCredentials.add(
              MongoCredential.createCredential(
                  credentials[0], databaseName, credentials[1].toCharArray()));
        }
      }

      if (serverAddresses.size() == 1)
        return new MongoClient(serverAddresses.get(0), mongoCredentials, options);
      else return new MongoClient(serverAddresses, mongoCredentials, options);

    } catch (UnknownHostException e) {
      handleConfigurationException("The URI: '" + currentURI + "' has a bad hostname", e);
    } catch (URISyntaxException e) {
      handleConfigurationException("The URI: '" + currentURI + "' is not a proper URI", e);
    }

    return null;
  }
示例#11
0
  /**
   * Factory method for creating a MongoDB provider within the plugin manager.
   *
   * @param collectionName The name of the MongoDB collection to which log events should be written.
   * @param writeConcernConstant The {@link WriteConcern} constant to control writing details,
   *     defaults to {@link WriteConcern#ACKNOWLEDGED}.
   * @param writeConcernConstantClassName The name of a class containing the aforementioned static
   *     WriteConcern constant. Defaults to {@link WriteConcern}.
   * @param databaseName The name of the MongoDB database containing the collection to which log
   *     events should be written. Mutually exclusive with {@code
   *     factoryClassName&factoryMethodName!=null}.
   * @param server The host name of the MongoDB server, defaults to localhost and mutually exclusive
   *     with {@code factoryClassName&factoryMethodName!=null}.
   * @param port The port the MongoDB server is listening on, defaults to the default MongoDB port
   *     and mutually exclusive with {@code factoryClassName&factoryMethodName!=null}.
   * @param userName The username to authenticate against the MongoDB server with.
   * @param password The password to authenticate against the MongoDB server with.
   * @param factoryClassName A fully qualified class name containing a static factory method capable
   *     of returning a {@link DB} or a {@link MongoClient}.
   * @param factoryMethodName The name of the public static factory method belonging to the
   *     aforementioned factory class.
   * @return a new MongoDB provider.
   */
  @PluginFactory
  public static MongoDbProvider createNoSqlProvider(
      @PluginAttribute("collectionName") final String collectionName,
      @PluginAttribute("writeConcernConstant") final String writeConcernConstant,
      @PluginAttribute("writeConcernConstantClass") final String writeConcernConstantClassName,
      @PluginAttribute("databaseName") final String databaseName,
      @PluginAttribute(value = "server", defaultString = "localhost") @ValidHost
          final String server,
      @PluginAttribute(value = "port", defaultString = "" + DEFAULT_PORT) @ValidPort
          final String port,
      @PluginAttribute("userName") final String userName,
      @PluginAttribute(value = "password", sensitive = true) final String password,
      @PluginAttribute("factoryClassName") final String factoryClassName,
      @PluginAttribute("factoryMethodName") final String factoryMethodName) {
    DB database;
    String description;
    if (Strings.isNotEmpty(factoryClassName) && Strings.isNotEmpty(factoryMethodName)) {
      try {
        final Class<?> factoryClass = LoaderUtil.loadClass(factoryClassName);
        final Method method = factoryClass.getMethod(factoryMethodName);
        final Object object = method.invoke(null);

        if (object instanceof DB) {
          database = (DB) object;
        } else if (object instanceof MongoClient) {
          if (Strings.isNotEmpty(databaseName)) {
            database = ((MongoClient) object).getDB(databaseName);
          } else {
            LOGGER.error(
                "The factory method [{}.{}()] returned a MongoClient so the database name is "
                    + "required.",
                factoryClassName,
                factoryMethodName);
            return null;
          }
        } else if (object == null) {
          LOGGER.error(
              "The factory method [{}.{}()] returned null.", factoryClassName, factoryMethodName);
          return null;
        } else {
          LOGGER.error(
              "The factory method [{}.{}()] returned an unsupported type [{}].",
              factoryClassName,
              factoryMethodName,
              object.getClass().getName());
          return null;
        }

        description = "database=" + database.getName();
        final List<ServerAddress> addresses = database.getMongo().getAllAddress();
        if (addresses.size() == 1) {
          description +=
              ", server=" + addresses.get(0).getHost() + ", port=" + addresses.get(0).getPort();
        } else {
          description += ", servers=[";
          for (final ServerAddress address : addresses) {
            description += " { " + address.getHost() + ", " + address.getPort() + " } ";
          }
          description += "]";
        }
      } catch (final ClassNotFoundException e) {
        LOGGER.error("The factory class [{}] could not be loaded.", factoryClassName, e);
        return null;
      } catch (final NoSuchMethodException e) {
        LOGGER.error(
            "The factory class [{}] does not have a no-arg method named [{}].",
            factoryClassName,
            factoryMethodName,
            e);
        return null;
      } catch (final Exception e) {
        LOGGER.error(
            "The factory method [{}.{}()] could not be invoked.",
            factoryClassName,
            factoryMethodName,
            e);
        return null;
      }
    } else if (Strings.isNotEmpty(databaseName)) {
      final List<MongoCredential> credentials = new ArrayList<>();
      description = "database=" + databaseName;
      if (Strings.isNotEmpty(userName) && Strings.isNotEmpty(password)) {
        description +=
            ", username="******", passwordHash="
                + NameUtil.md5(password + MongoDbProvider.class.getName());
        credentials.add(
            MongoCredential.createCredential(userName, databaseName, password.toCharArray()));
      }
      try {
        final int portInt = TypeConverters.convert(port, int.class, DEFAULT_PORT);
        description += ", server=" + server + ", port=" + portInt;
        database =
            new MongoClient(new ServerAddress(server, portInt), credentials).getDB(databaseName);
      } catch (final Exception e) {
        LOGGER.error(
            "Failed to obtain a database instance from the MongoClient at server [{}] and "
                + "port [{}].",
            server,
            port);
        return null;
      }
    } else {
      LOGGER.error("No factory method was provided so the database name is required.");
      return null;
    }

    try {
      database.getCollectionNames(); // Check if the database actually requires authentication
    } catch (final Exception e) {
      LOGGER.error(
          "The database is not up, or you are not authenticated, try supplying a username and password to the MongoDB provider.",
          e);
      return null;
    }

    final WriteConcern writeConcern =
        toWriteConcern(writeConcernConstant, writeConcernConstantClassName);

    return new MongoDbProvider(database, writeConcern, collectionName, description);
  }