/** * never return null; * * @param context * @return */ public static String getDeviceSerial(Context context) { UUID uuid = null; final String androidId = Secure.getString(context.getContentResolver(), Secure.ANDROID_ID); // Use the Android ID unless it's broken, in which case fallback on deviceId, // unless it's not available, then fallback on a random number which we store // to a prefs file try { if (!"9774d56d682e549c".equals(androidId)) { uuid = UUID.nameUUIDFromBytes(androidId.getBytes("utf8")); } else { final String deviceId = ((TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE)).getDeviceId(); uuid = deviceId != null ? UUID.nameUUIDFromBytes(deviceId.getBytes("utf8")) : UUID.randomUUID(); } } catch (UnsupportedEncodingException e) { Log.w(TAG, "exception", e); uuid = UUID.randomUUID(); } return uuid.toString(); }
private static void addPacket( Player p, String msg, int slotId, WrappedGameProfile gameProfile, boolean b, int ping) { PacketContainer message = protocolManager.createPacket(PacketType.Play.Server.PLAYER_INFO); String nameToShow = (!shuttingdown ? "$" : "") + msg; if (protocolManager.getProtocolVersion(p) >= 47) { nameToShow = (!shuttingdown ? "$" : "") + ChatColor.DARK_GRAY + slotId + ": " + msg.substring(0, Math.min(msg.length(), 10)); } EnumWrappers.PlayerInfoAction action; if (b) { action = EnumWrappers.PlayerInfoAction.ADD_PLAYER; } else { action = EnumWrappers.PlayerInfoAction.REMOVE_PLAYER; } message.getPlayerInfoAction().write(0, action); List<PlayerInfoData> pInfoData = new ArrayList<PlayerInfoData>(); if (gameProfile != null) { pInfoData.add( new PlayerInfoData( gameProfile .withName(nameToShow.substring(1)) .withId( UUID.nameUUIDFromBytes( ("OfflinePlayer:" + nameToShow.substring(1)).getBytes(Charsets.UTF_8)) .toString()), ping, EnumWrappers.NativeGameMode.SURVIVAL, WrappedChatComponent.fromText(nameToShow))); } else { pInfoData.add( new PlayerInfoData( new WrappedGameProfile( UUID.nameUUIDFromBytes( ("OfflinePlayer:" + nameToShow.substring(1)).getBytes(Charsets.UTF_8)), nameToShow.substring(1)), ping, EnumWrappers.NativeGameMode.SURVIVAL, WrappedChatComponent.fromText(nameToShow))); } message.getPlayerInfoDataLists().write(0, pInfoData); List<PacketContainer> packetList = cachedPackets.get(p); if (packetList == null) { packetList = new ArrayList<PacketContainer>(); cachedPackets.put(p, packetList); } packetList.add(message); }
@Test public void testCreateWithDelegate_UUID() throws Exception { UUID uuid = UUID.nameUUIDFromBytes("uuid".getBytes()); BiochemicalReaction rxn = BiochemRxnImpl.createWithDelegate(uuid); assertNotNull(rxn.getMetabolicReaction()); assertThat(rxn.getMetabolicReaction().uuid(), is(uuid)); }
public List<TransferredResource> createCorpora() throws InterruptedException, IOException, FileAlreadyExistsException, NotFoundException, GenericException, AlreadyExistsException, SolrServerException, IsStillUpdatingException { TransferredResourcesScanner f = RodaCoreFactory.getTransferredResourcesScanner(); List<TransferredResource> resources = new ArrayList<TransferredResource>(); Path corpora = corporaPath .resolve(RodaConstants.STORAGE_CONTAINER_AIP) .resolve(CorporaConstants.SOURCE_AIP_CONVERTER_3) .resolve(RodaConstants.STORAGE_DIRECTORY_REPRESENTATIONS) .resolve(CorporaConstants.REPRESENTATION_CONVERTER_ID_3) .resolve(RodaConstants.STORAGE_DIRECTORY_DATA); String transferredResourceId = "testt"; FSUtils.copy(corpora, f.getBasePath().resolve(transferredResourceId), true); f.updateTransferredResources(Optional.empty(), true); index.commit(TransferredResource.class); resources.add( index.retrieve( TransferredResource.class, UUID.nameUUIDFromBytes(transferredResourceId.getBytes()).toString())); return resources; }
@Test @SuppressWarnings("unchecked") public void modificationDuringTransactionCausesAbort() throws Exception { Map<String, String> testMap = getRuntime().getObjectsView().open(CorfuRuntime.getStreamID("A"), SMRMap.class); assertThat(testMap.put("a", "z")); getRuntime().getObjectsView().TXBegin(); assertThat(testMap.put("a", "a")).isEqualTo("z"); assertThat(testMap.put("a", "b")).isEqualTo("a"); assertThat(testMap.get("a")).isEqualTo("b"); CompletableFuture cf = CompletableFuture.runAsync( () -> { Map<String, String> testMap2 = getRuntime() .getObjectsView() .open( UUID.nameUUIDFromBytes("A".getBytes()), SMRMap.class, null, EnumSet.of(ObjectOpenOptions.NO_CACHE), SerializerType.JSON); testMap2.put("a", "f"); }); cf.join(); assertThatThrownBy(() -> getRuntime().getObjectsView().TXEnd()) .isInstanceOf(TransactionAbortedException.class); }
@Override public void uncaughtException(Thread arg0, Throwable arg1) { // 把错误的堆栈信息 获取出来 String errorInfo = getErrorInfo(arg1); String uuidKey = UUID.nameUUIDFromBytes(errorInfo.getBytes()).toString(); String existsException = Utils.getSharedPreferences("uncaughtException").getString(uuidKey, ""); if (!existsException.equals("")) { // -- this uncaughtException has got Debug.Log("Exception has got yet: " + errorInfo); Debug.Log("kill self() "); android.os.Process.killProcess(android.os.Process.myPid()); return; } Editor editor = Utils.getSharedPreferences("uncaughtException").edit(); editor.putString(uuidKey, "Mark"); editor.commit(); String content = DeviceInfo.getInfo(context).toString(); String msg = content + "\nStack:\n" + errorInfo; Debug.Log("uncaughtException: " + msg); errorContent = msg; // sendExceptionMsg(); }
public DeleteStoragePoolCommand(StoragePool pool) { this( pool, LOCAL_PATH_PREFIX + File.separator + UUID.nameUUIDFromBytes((pool.getHostAddress() + pool.getPath()).getBytes())); }
@Test public void shouldSavePlayerData() { // given Player player = mock(Player.class); UUID uuid = UUID.nameUUIDFromBytes("New player".getBytes()); given(player.getUniqueId()).willReturn(uuid); given(permissionsManager.getPrimaryGroup(player)).willReturn("primary-grp"); given(player.isOp()).willReturn(true); given(player.getWalkSpeed()).willReturn(1.2f); given(player.getFlySpeed()).willReturn(0.8f); given(player.getAllowFlight()).willReturn(true); World world = mock(World.class); given(world.getName()).willReturn("player-world"); Location location = new Location(world, 0.2, 102.25, -89.28, 3.02f, 90.13f); given(spawnLoader.getPlayerLocationOrSpawn(player)).willReturn(location); // when limboPlayerStorage.saveData(player); // then File playerFile = new File(dataFolder, FileUtils.makePath("playerdata", uuid.toString(), "data.json")); assertThat(playerFile.exists(), equalTo(true)); // TODO ljacqu 20160711: Check contents of file }
public static String fromSeed(String seed) { StringBuilder sb = new StringBuilder(); UUID uuid = UUID.nameUUIDFromBytes(seed.getBytes()); sb.append( String.format("%016x%016x", uuid.getMostSignificantBits(), uuid.getLeastSignificantBits())); return sb.toString(); }
static { try { emptyVersion = UUID.nameUUIDFromBytes(MessageDigest.getInstance("MD5").digest()); } catch (NoSuchAlgorithmException e) { throw new AssertionError(); } }
@Test public void testCreatePrimaryStorage() { DataStoreProvider provider = dataStoreProviderMgr.getDataStoreProvider("sample primary data store provider"); Map<String, Object> params = new HashMap<String, Object>(); URI uri = null; try { uri = new URI(this.getPrimaryStorageUrl()); } catch (URISyntaxException e) { // TODO Auto-generated catch block e.printStackTrace(); } params.put("url", this.getPrimaryStorageUrl()); params.put("server", uri.getHost()); params.put("path", uri.getPath()); params.put("protocol", StoragePoolType.NetworkFilesystem); params.put("dcId", dcId.toString()); params.put("clusterId", clusterId.toString()); params.put("name", this.primaryName); params.put("port", "1"); params.put("roles", DataStoreRole.Primary.toString()); params.put("uuid", UUID.nameUUIDFromBytes(this.getPrimaryStorageUrl().getBytes()).toString()); params.put("providerName", String.valueOf(provider.getName())); DataStoreLifeCycle lifeCycle = provider.getDataStoreLifeCycle(); this.primaryStore = lifeCycle.initialize(params); ClusterScope scope = new ClusterScope(clusterId, podId, dcId); lifeCycle.attachCluster(this.primaryStore, scope); }
private static void a(Context paramContext, File paramFile) { FileOutputStream localFileOutputStream = new FileOutputStream(paramFile); byte[] arrayOfByte1 = Settings.Secure.getString(paramContext.getContentResolver(), "android_id").getBytes(); Time localTime = new Time(); localTime.setToNow(); byte[] arrayOfByte2 = new byte[6 + arrayOfByte1.length]; for (int i = 0; ; i++) { if (i >= arrayOfByte1.length) { int j = i + 1; arrayOfByte2[i] = ((byte) localTime.year); int k = j + 1; arrayOfByte2[j] = ((byte) localTime.month); int m = k + 1; arrayOfByte2[k] = ((byte) localTime.monthDay); int n = m + 1; arrayOfByte2[m] = ((byte) localTime.hour); int i1 = n + 1; arrayOfByte2[n] = ((byte) localTime.minute); arrayOfByte2[i1] = ((byte) localTime.second); String str = UUID.nameUUIDFromBytes(arrayOfByte2).toString(); System.out.println("uuid.." + str); localFileOutputStream.write(str.getBytes()); return; } arrayOfByte2[i] = arrayOfByte1[i]; } }
public UUID getRelHash() { if (relHash_ == null) { relHash_ = UUID.nameUUIDFromBytes(new String(rel + rela + sourceUUID_ + targetUUID_).getBytes()); } return relHash_; }
@JsonIgnore public UUID getId() { if (id == null) { id = UUID.nameUUIDFromBytes(getIdString().getBytes()); } return id; }
/** * @param identifier * @return a generated id for the given string identifier */ static String getId(String identifier) { try { // TODO find a better algorithm, UUID is using MD5 return UUID.nameUUIDFromBytes(identifier.getBytes("UTF-8")).toString(); } catch (UnsupportedEncodingException e) { throw new IllegalStateException(e); } }
/** * The generated UUID of a page is based on the Wiki name and the page name (or path). * * @param p * @return * @throws IOException */ private String mkUuid(String wiki, String name) throws IOException { ByteArrayOutputStream out = new ByteArrayOutputStream(); out.write(wiki.getBytes("UTF-8")); out.write(name.getBytes("UTF-8")); return UUID.nameUUIDFromBytes(out.toByteArray()).toString(); }
@Test public void testSerialization() { MessagePack msgpack = new MessagePack(); msgpack.register( RexProMessageMeta.class, RexProMessageMeta.SerializationTemplate.getInstance()); msgpack.register(RexProBindings.class, RexProBindings.SerializationTemplate.getInstance()); msgpack.register( RexProScriptResult.class, RexProScriptResult.SerializationTemplate.getInstance()); ConsoleScriptResponseMessage outMsg = new ConsoleScriptResponseMessage(); outMsg.setRequestAsUUID(UUID.randomUUID()); outMsg.setSessionAsUUID(UUID.randomUUID()); outMsg.ConsoleLines = new String[2]; outMsg.ConsoleLines[0] = "a"; outMsg.ConsoleLines[1] = "b"; outMsg.Bindings.put("o", 1); final ByteArrayOutputStream outStream = new ByteArrayOutputStream(); final Packer packer = msgpack.createPacker(outStream); try { packer.write(outMsg); packer.close(); } catch (IOException ex) { Assert.fail(); } byte[] bytes = outStream.toByteArray(); final ByteArrayInputStream in = new ByteArrayInputStream(bytes); final Unpacker unpacker = msgpack.createUnpacker(in); ConsoleScriptResponseMessage inMsg; try { inMsg = unpacker.read(ConsoleScriptResponseMessage.class); Assert.assertEquals(outMsg.Meta, inMsg.Meta); Assert.assertEquals( UUID.nameUUIDFromBytes(outMsg.Request), UUID.nameUUIDFromBytes(inMsg.Request)); Assert.assertEquals( UUID.nameUUIDFromBytes(outMsg.Session), UUID.nameUUIDFromBytes(inMsg.Session)); Assert.assertTrue(Arrays.deepEquals(outMsg.ConsoleLines, inMsg.ConsoleLines)); Assert.assertEquals(inMsg.Bindings.get("o"), 1); } catch (IOException ex) { Assert.fail(); } }
@Override public void run() { boolean verify = this.session.hasFlag(MinecraftConstants.VERIFY_USERS_KEY) ? this.session.<Boolean>getFlag(MinecraftConstants.VERIFY_USERS_KEY) : true; GameProfile profile = null; if (verify && this.key != null) { Proxy proxy = this.session.<Proxy>getFlag(MinecraftConstants.AUTH_PROXY_KEY); if (proxy == null) { proxy = Proxy.NO_PROXY; } try { profile = new SessionService(proxy) .getProfileByServer( username, new BigInteger( CryptUtil.getServerIdHash(serverId, KEY_PAIR.getPublic(), this.key)) .toString(16)); } catch (RequestException e) { this.session.disconnect("Failed to make session service request.", e); return; } if (profile == null) { this.session.disconnect("Failed to verify username."); } } else { profile = new GameProfile( UUID.nameUUIDFromBytes(("OfflinePlayer:" + username).getBytes()), username); } int threshold; if (this.session.hasFlag(MinecraftConstants.SERVER_COMPRESSION_THRESHOLD)) { threshold = this.session.getFlag(MinecraftConstants.SERVER_COMPRESSION_THRESHOLD); } else { threshold = 256; } this.session.send(new LoginSetCompressionPacket(threshold)); this.session.setCompressionThreshold(threshold); this.session.send(new LoginSuccessPacket(profile)); this.session.setFlag(MinecraftConstants.PROFILE_KEY, profile); ((MinecraftProtocol) this.session.getPacketProtocol()) .setSubProtocol(SubProtocol.GAME, false, this.session); ServerLoginHandler handler = this.session.getFlag(MinecraftConstants.SERVER_LOGIN_HANDLER_KEY); if (handler != null) { handler.loggedIn(this.session); } new Thread(new KeepAliveTask(this.session)).start(); }
public static String makeGUID( final String catalog, final String schema, final String table, final String column) { final String t = StringUtils.defaultString(catalog) + StringUtils.defaultString(schema) + StringUtils.defaultString(table) + StringUtils.defaultString(column); return "v_" + (UUID.nameUUIDFromBytes(t.getBytes()).toString().replace("-", "_")); }
public AttributeModifier build() { AttributeModifier modifier = new AttributeModifier( UUID.nameUUIDFromBytes(name.getBytes(StandardCharsets.US_ASCII)), name, value, operation.ordinal()); modifier.setSaved(isSaved); return modifier; }
public UUID getInverseRelHash(RRFBaseConverterMojo bc) { // reverse the direction of the rels, and the source/target String relInverse = bc.nameToRel_.get(rel).getFSNName(); String relaInverse = null; if (rela != null) { relaInverse = bc.nameToRel_.get(rela).getFSNName(); } return UUID.nameUUIDFromBytes( new String(relInverse + relaInverse + targetUUID_ + sourceUUID_).getBytes()); }
@Override public AuthenticationResponse authenticate(String username, Object... aditionalArgs) { AuthenticationResponse response = new AuthenticationResponse( true, "redstonelamp.authSuccess", UUID.nameUUIDFromBytes(username.getBytes())); if (getManager().getServer().getOnlinePlayers().size() > getManager().getServer().getMaxPlayers()) { response = new AuthenticationResponse(false, "redstonelamp.authFailed.serverFull", null); } return response; }
@Test public void shouldReturnIfHasData() { // given Player player1 = mock(Player.class); given(player1.getUniqueId()).willReturn(SAMPLE_UUID); Player player2 = mock(Player.class); given(player2.getUniqueId()).willReturn(UUID.nameUUIDFromBytes("not-stored".getBytes())); // when / then assertThat(limboPlayerStorage.hasData(player1), equalTo(true)); assertThat(limboPlayerStorage.hasData(player2), equalTo(false)); }
@Test public void shouldReturnNullForUnavailablePlayer() { // given Player player = mock(Player.class); given(player.getUniqueId()).willReturn(UUID.nameUUIDFromBytes("other-player".getBytes())); // when LimboPlayer data = limboPlayerStorage.readData(player); // then assertThat(data, nullValue()); }
public final class d { private static String a = null; private static final String b = "INSTALLATION-" + UUID.nameUUIDFromBytes("androidkit".getBytes()); public static String a(Context paramContext) { try { File localFile; if (a == null) localFile = new File(paramContext.getFilesDir(), b); try { if (!localFile.exists()) a(paramContext, localFile); RandomAccessFile localRandomAccessFile = new RandomAccessFile(localFile, "r"); byte[] arrayOfByte = new byte[(int) localRandomAccessFile.length()]; localRandomAccessFile.readFully(arrayOfByte); localRandomAccessFile.close(); a = new String(arrayOfByte); String str = a; return str; } catch (IOException localIOException) { while (true) localIOException.printStackTrace(); } } finally { } } private static void a(Context paramContext, File paramFile) { FileOutputStream localFileOutputStream = new FileOutputStream(paramFile); byte[] arrayOfByte1 = Settings.Secure.getString(paramContext.getContentResolver(), "android_id").getBytes(); Time localTime = new Time(); localTime.setToNow(); byte[] arrayOfByte2 = new byte[6 + arrayOfByte1.length]; for (int i = 0; ; i++) { if (i >= arrayOfByte1.length) { int j = i + 1; arrayOfByte2[i] = ((byte) localTime.year); int k = j + 1; arrayOfByte2[j] = ((byte) localTime.month); int m = k + 1; arrayOfByte2[k] = ((byte) localTime.monthDay); int n = m + 1; arrayOfByte2[m] = ((byte) localTime.hour); int i1 = n + 1; arrayOfByte2[n] = ((byte) localTime.minute); arrayOfByte2[i1] = ((byte) localTime.second); String str = UUID.nameUUIDFromBytes(arrayOfByte2).toString(); System.out.println("uuid.." + str); localFileOutputStream.write(str.getBytes()); return; } arrayOfByte2[i] = arrayOfByte1[i]; } } }
// [JACKSON-726] public void testUUIDKeyMap() throws Exception { ObjectMapper mapper = new ObjectMapper(); UUID key = UUID.nameUUIDFromBytes("foobar".getBytes("UTF-8")); String JSON = "{ \"" + key + "\":4}"; Map<UUID, Object> result = mapper.readValue(JSON, new TypeReference<Map<UUID, Object>>() {}); assertNotNull(result); assertEquals(1, result.size()); Object ob = result.keySet().iterator().next(); assertNotNull(ob); assertEquals(UUID.class, ob.getClass()); assertEquals(key, ob); }
public DataStore createPrimaryDataStore() { try { DataStoreProvider provider = dataStoreProviderMgr.getDataStoreProvider("sample primary data store provider"); Map<String, Object> params = new HashMap<String, Object>(); URI uri = new URI(this.getPrimaryStorageUrl()); params.put("url", this.getPrimaryStorageUrl()); params.put("server", uri.getHost()); params.put("path", uri.getPath()); params.put("protocol", Storage.StoragePoolType.NetworkFilesystem); params.put("dcId", dcId.toString()); params.put("clusterId", clusterId.toString()); params.put("name", this.primaryName); params.put("port", "1"); params.put("roles", DataStoreRole.Primary.toString()); params.put("uuid", UUID.nameUUIDFromBytes(this.getPrimaryStorageUrl().getBytes()).toString()); params.put("providerName", String.valueOf(provider.getName())); DataStoreLifeCycle lifeCycle = provider.getDataStoreLifeCycle(); DataStore store = lifeCycle.initialize(params); ClusterScope scope = new ClusterScope(clusterId, podId, dcId); lifeCycle.attachCluster(store, scope); /* * PrimaryDataStoreProvider provider = * primaryDataStoreProviderMgr.getDataStoreProvider * ("sample primary data store provider"); * primaryDataStoreProviderMgr.configure("primary data store mgr", * new HashMap<String, Object>()); * * List<PrimaryDataStoreVO> ds = * primaryStoreDao.findPoolByName(this.primaryName); if (ds.size() * >= 1) { PrimaryDataStoreVO store = ds.get(0); if * (store.getRemoved() == null) { return * provider.getDataStore(store.getId()); } } * * * Map<String, String> params = new HashMap<String, String>(); * params.put("url", this.getPrimaryStorageUrl()); * params.put("dcId", dcId.toString()); params.put("clusterId", * clusterId.toString()); params.put("name", this.primaryName); * PrimaryDataStoreInfo primaryDataStoreInfo = * provider.registerDataStore(params); PrimaryDataStoreLifeCycle lc * = primaryDataStoreInfo.getLifeCycle(); ClusterScope scope = new * ClusterScope(clusterId, podId, dcId); lc.attachCluster(scope); * return primaryDataStoreInfo; */ return store; } catch (Exception e) { return null; } }
private static String genKeyFromMap(Map map) { StringBuilder mapToString = new StringBuilder(); Set<Map.Entry<Writable, WritableComparable>> entrySet = map.entrySet(); for (Map.Entry<Writable, WritableComparable> entry : entrySet) { mapToString.append(entry.getKey().toString()).append(":"); mapToString.append(entry.getValue().toString()).append(";"); } logger.info("Map as string: " + mapToString.toString()); return UUID.nameUUIDFromBytes(mapToString.toString().getBytes()).toString(); }
public DataStore createPrimaryDataStore() { try { String uuid = UUID.nameUUIDFromBytes(this.getPrimaryStorageUrl().getBytes()).toString(); List<StoragePoolVO> pools = primaryDataStoreDao.findPoolByName(this.primaryName); if (pools.size() > 0) { return this.dataStoreMgr.getPrimaryDataStore(pools.get(0).getId()); } /* * DataStoreProvider provider = * dataStoreProviderMgr.getDataStoreProvider * ("cloudstack primary data store provider"); Map<String, Object> * params = new HashMap<String, Object>(); URI uri = new * URI(this.getPrimaryStorageUrl()); params.put("url", * this.getPrimaryStorageUrl()); params.put("server", * uri.getHost()); params.put("path", uri.getPath()); * params.put("protocol", * Storage.StoragePoolType.NetworkFilesystem); params.put("zoneId", * dcId); params.put("clusterId", clusterId); params.put("name", * this.primaryName); params.put("port", 1); params.put("podId", * this.podId); params.put("roles", * DataStoreRole.Primary.toString()); params.put("uuid", uuid); * params.put("providerName", String.valueOf(provider.getName())); * * DataStoreLifeCycle lifeCycle = provider.getDataStoreLifeCycle(); * DataStore store = lifeCycle.initialize(params); ClusterScope * scope = new ClusterScope(clusterId, podId, dcId); * lifeCycle.attachCluster(store, scope); */ StoragePoolVO pool = new StoragePoolVO(); pool.setClusterId(clusterId); pool.setDataCenterId(dcId); URI uri = new URI(this.getPrimaryStorageUrl()); pool.setHostAddress(uri.getHost()); pool.setPath(uri.getPath()); pool.setPort(0); pool.setName(this.primaryName); pool.setUuid(this.getPrimaryStorageUuid()); pool.setStatus(StoragePoolStatus.Up); pool.setPoolType(StoragePoolType.VMFS); pool.setPodId(podId); pool.setScope(ScopeType.CLUSTER); pool.setStorageProviderName("cloudstack primary data store provider"); pool = this.primaryStoreDao.persist(pool); DataStore store = this.dataStoreMgr.getPrimaryDataStore(pool.getId()); return store; } catch (Exception e) { return null; } }
@Override public guid key() { if (key == null) { String ownerName = owner != null ? owner.name() : null; String name = name(); if (name == null) throw new UnsupportedOperationException(); String value = (ownerName != null ? ownerName + "." : "") + name; key = new guid(UUID.nameUUIDFromBytes(value.getBytes())); } return key; }