Refine search
public static void main(String[] args) throws IOException { String serverString = args[0]; RemoteApiOptions options; if (serverString.equals("localhost")) { options = new RemoteApiOptions().server(serverString, 8080).useDevelopmentServerCredential(); } else { options = new RemoteApiOptions().server(serverString, 443).useApplicationDefaultCredential(); } RemoteApiInstaller installer = new RemoteApiInstaller(); installer.install(options); try { DatastoreService ds = DatastoreServiceFactory.getDatastoreService(); System.out.println("Key of new entity is " + ds.put(new Entity("Hello Remote API!"))); } finally { installer.uninstall(); } } }
/** * You can override this to add behavior at the raw datastoreservice level. */ protected AsyncDatastoreService getRawAsyncDatastoreService(DatastoreServiceConfig cfg) { return DatastoreServiceFactory.getAsyncDatastoreService(cfg); }
@Override public List<String> listNamespaces() { DatastoreService ds = DatastoreServiceFactory.getDatastoreService(); Query query = new Query("__namespace__").setKeysOnly(); PreparedQuery pq = ds.prepare(query); List<String> namespaces = new ArrayList<>(); for (Entity entity : pq.asIterable()) { namespaces.add(entity.getKey().getName()); } return namespaces; }
@Test @WithinNamespace({ "", "Ns1" }) public void testSmoke() throws Exception { final DatastoreService ds = DatastoreServiceFactory.getDatastoreService(); Key key = ds.put(new Entity("NsTest")); try { Assert.assertNotNull(ds.get(key)); } finally { ds.delete(key); } } }
/** * You can override this to add behavior at the raw datastoreservice level. */ protected DatastoreService getRawDatastoreService(DatastoreServiceConfig cfg) { return DatastoreServiceFactory.getDatastoreService(cfg); }
@Test(expected = IllegalArgumentException.class) public void testTransactionalTasksMustBeNamelessIterable() { Transaction tx = DatastoreServiceFactory.getDatastoreService().beginTransaction(); try { getDefaultQueue().add(tx, Collections.singleton(TaskOptions.Builder.withTaskName("foo"))); } finally { tx.rollback(); } }
@Override public void deleteAll(String namespace) { NamespaceManager.set(namespace); DatastoreService datastore = DatastoreServiceFactory.getDatastoreService(); Query query = new Query(); PreparedQuery pq = datastore.prepare(query); for (Entity entity : pq.asIterable()) { String kind = entity.getKind(); if (kind.startsWith("__") && !kind.contains("yawp")) { continue; } datastore.delete(entity.getKey()); } }
private static Map<String, Object> load() { DatastoreService datastore = DatastoreServiceFactory.getDatastoreService(); Key key = KeyFactory.createKey("_settings", 1); Entity leanEntity; try { leanEntity = datastore.get(key); settings = leanEntity.getProperties(); } catch (EntityNotFoundException e) { settings = new HashMap<String, Object>(); // By default enable all logins on Development server if (ServerUtils.isDevServer()) { settings.put("fbLoginEnable", true); settings.put("fbAppId", "mockFacebookAppId"); settings.put("fbAppSecret", "mockFacebookAppSecret"); settings.put("openIdLoginEnable", true); saveSettings(settings); } } return settings; }
@Test public void putStoresEntity() throws Exception { DatastoreService ds = DatastoreServiceFactory.getDatastoreService(); Entity client = new Entity("Client"); client.setProperty("username", "alesj"); client.setProperty("password", "password"); final Key key = ds.put(client); try { Query query = new Query("Client"); query.setFilter(new Query.FilterPredicate("username", Query.FilterOperator.EQUAL, "alesj")); PreparedQuery pq = ds.prepare(query); Entity result = pq.asSingleEntity(); Assert.assertNotNull(result); Assert.assertEquals(key, result.getKey()); Assert.assertEquals("alesj", result.getProperty("username")); Assert.assertEquals("password", result.getProperty("password")); } finally { ds.delete(key); } }
public static Key putTempData(TempData data) { DatastoreService ds = DatastoreServiceFactory.getDatastoreService(); Transaction txn = ds.beginTransaction(TransactionOptions.Builder.withXG(true)); try { Class<? extends TempData> type = data.getClass(); String kind = getKind(type); Entity entity = new Entity(kind); for (Map.Entry<String, Object> entry : data.toProperties(ds).entrySet()) { entity.setProperty(entry.getKey(), entry.getValue()); } entity.setProperty(TEMP_DATA_READ_PROPERTY, false); data.prePut(ds); Key key = ds.put(txn, entity); data.postPut(ds); txn.commit(); return key; } catch (Exception e) { throw new IllegalStateException(e); } finally { if (txn.isActive()) { txn.rollback(); } } }
public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException { log.info("Ping - " + req); if (requestHandler != null) { requestHandler.handleRequest(req); } lastRequest = req; final DatastoreService ds = DatastoreServiceFactory.getDatastoreService(); try { Entity entity = new Entity("Qwert"); entity.setProperty("xyz", 123); Key key = ds.put(entity); entity = ds.get(key); log.info(entity.toString()); FileService fs = FileServiceFactory.getFileService(); AppEngineFile file = fs.createNewBlobFile("qwertfile"); FileWriteChannel fwc = fs.openWriteChannel(file, false); try { log.info("b_l = " + fwc.write(ByteBuffer.wrap("qwert".getBytes()))); } finally { fwc.close(); } } catch (Exception e) { throw new IOException(e); } }
@Override public void delete(String userId, Credential credential) { DatastoreService datastore = DatastoreServiceFactory.getDatastoreService(); Key key = KeyFactory.createKey(KIND, userId); datastore.delete(key); }
/** * Should work in all envs? * A bit complex / overkill ... * * @return true if in-container, false otherewise */ protected static boolean isInContainer() { try { DatastoreService ds = DatastoreServiceFactory.getDatastoreService(); Transaction tx = ds.beginTransaction(); try { return (ds.getCurrentTransaction() != null); } finally { tx.rollback(); } } catch (Throwable ignored) { return false; } }
@Before public void clearData() { asyncService = DatastoreServiceFactory.getAsyncDatastoreService(); List<Key> elist = new ArrayList<Key>(); Query query = new Query(ASYNC_ENTITY); for (Entity readRec : service.prepare(query).asIterable()) { elist.add(readRec.getKey()); } service.delete(elist); }
/** * Preallocate a contiguous range of unique ids within the namespace of the * specified entity class. These ids can be used in concert with the normal * automatic allocation of ids when put()ing entities with null Long id fields. * * @param clazz must be a registered entity class with a Long or long id field. * @param num must be >= 1 and <= 1 billion */ public <T> KeyRange<T> allocateIds(Class<T> clazz, long num) { // Feels a little weird going directly to the DatastoreServiceFactory but the // allocateIds() method really is optionless. String kind = Key.getKind(clazz); return new KeyRange<T>(DatastoreServiceFactory.getDatastoreService().allocateIds(kind, num)); }
/** * Allocates a user-specified contiguous range of unique IDs, preventing the allocator from * giving them out to entities (with autogeneration) or other calls to allocate methods. * This lets you specify a specific range to block out (for example, you are bulk-loading a * collection of pre-existing entities). If you don't care about what id is allocated, use * one of the other allocate methods. */ public <T> KeyRangeState allocateIdRange(KeyRange<T> range) { return DatastoreServiceFactory.getDatastoreService().allocateIdRange(range.getRaw()); }
public static <T extends TempData> T getLastTempData(Class<T> type) { try { DatastoreService ds = DatastoreServiceFactory.getDatastoreService(); String kind = getKind(type); PreparedQuery pq = ds.prepare(new Query(kind).addSort("timestamp", Query.SortDirection.DESCENDING)); Iterator<Entity> iter = pq.asIterator(); if (iter.hasNext()) { Entity entity = iter.next(); return readTempData(type, entity, ds); } else { return null; } } catch (Exception e) { throw new IllegalStateException(e); } }
@Test public void testAutoPolicy() throws Exception { DatastoreServiceConfig config = DatastoreServiceConfig.Builder.withImplicitTransactionManagementPolicy(ImplicitTransactionManagementPolicy.AUTO); DatastoreService ds = DatastoreServiceFactory.getDatastoreService(config); Transaction tx = ds.beginTransaction(); try { k1 = ds.put(new Entity("PutAutoTx")); } finally { tx.rollback(); Assert.assertTrue(ds.get(Collections.singleton(k1)).isEmpty()); k1 = ds.put(new Entity("DeleteAutoTx"));
private DatastoreService datastore() { if (ds == null) { ds = DatastoreServiceFactory.getDatastoreService(); } return ds; }
protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { String entityGroup = req.getParameter("eg"); String counter = req.getParameter("c"); String parent = req.getParameter("p"); boolean xg = Boolean.parseBoolean(req.getParameter("xg")); Key parentKey = "2".equals(parent) ? ROOT_2.getKey() : ROOT_1.getKey(); Entity entity = new Entity(entityGroup, parentKey); entity.setProperty("foo", RANDOM.nextInt()); DatastoreService ds = DatastoreServiceFactory.getDatastoreService(); final Transaction tx = ds.beginTransaction(TransactionOptions.Builder.withXG(xg)); try { log.warning("Before put ... " + counter); putEntity(ds, entity); log.warning("After put ... " + counter); tx.commit(); resp.getWriter().write("OK" + counter); } catch (Exception e) { log.warning("Error ... " + e); tx.rollback(); resp.getWriter().write("ERROR" + counter + ":" + e.getClass().getName()); error(counter); } finally { cleanup(counter); } }