Java Code Examples for java.util.UUID

@Test public void testSetAttribute() throws Exception {
  mbeanServerConnection.setAttribute(testMBeanName,new Attribute("Value","Foo"));
  assertEquals(testMBean.getValue(),"Foo");
  mbeanServerConnection.setAttribute(testMBeanName,new Attribute("Value",null));
  assertEquals(testMBean.getValue(),null);
  UUID uuid=UUID.randomUUID();
  mbeanServerConnection.setAttribute(testMBeanName,new Attribute("ObjectValue",uuid));
  assertEquals(testMBean.getObjectValue(),uuid);
  mbeanServerConnection.setAttribute(testMBeanName,new Attribute("ObjectValue",null));
  assertEquals(testMBean.getObjectValue(),null);
}
 

public static String getDeviceId(Context context){
  if (deviceId == null) {
    TelephonyManager tm=(TelephonyManager)context.getSystemService(Context.TELEPHONY_SERVICE);
    String tmDevice, tmSerial, tmPhone, androidId;
    tmDevice="" + tm.getDeviceId();
    tmSerial="" + tm.getSimSerialNumber();
    androidId="" + android.provider.Settings.Secure.getString(context.getContentResolver(),android.provider.Settings.Secure.ANDROID_ID);
    UUID deviceUuid=new UUID(androidId.hashCode(),((long)tmDevice.hashCode() << 32) | tmSerial.hashCode());
    deviceId=deviceUuid.toString();
    System.err.println(deviceId);
  }
  return deviceId;
}
 

@SuppressWarnings("unchecked") public Map<UUID,List<Volume>> getVolumes(){
  Map<UUID,List<Volume>> result=new LinkedHashMap();
  for (  Volume d : library) {
    UUID dictionaryId=d.getDictionaryId();
    if (!result.containsKey(dictionaryId)) {
      result.put(dictionaryId,new ArrayList<Volume>());
    }
    result.get(dictionaryId).add(d);
  }
  return result;
}
 

@Test public void testAdd() throws InterruptedException {
  long timestamp=System.currentTimeMillis();
  UUID uuid=TimeUUIDUtils.getTimeUUID(timestamp);
  String epochtime=new Long(timestamp).toString();
  String msgtype="auditd";
  String rowkey="chicgdatapp109.cg.bskyb.com";
  String hostname="";
  try {
    cassandraDao.insert(uuid,epochtime,msgtype,testLog,rowkey,hostname);
  }
 catch (  CassandraException e) {
    e.printStackTrace();
  }
}
 

private UUID mapKeyToUUID(String key){
  UUID uuid=cache.get(key);
  if (uuid == null) {
    uuid=UUIDUtil.md5UUID(key);
    cache.put(key,uuid);
  }
  return uuid;
}
 

@Test @Ignore public void testMicrosResolution(){
  Clock clock=new MicrosecondsSyncClock();
  long time=clock.getCurrentTime();
  UUID uuid=TimeUUIDUtils.getUniqueTimeUUIDinMicros();
  long uuidTime=TimeUUIDUtils.getMicrosTimeFromUUID(uuid);
  Assert.assertEquals(time / 10000,uuidTime / 10000);
}
 

@Test public void testBucketizeIdWithTimestamp2() throws IOException {
  UUID uuid=UUID.randomUUID();
  long ts=System.currentTimeMillis();
  byte[] idBytes=IdUtil.bucketizeId(uuid.toString(),ts);
  assertNotNull(idBytes);
  String bucketIdStr=new String(idBytes);
  assertTrue(bucketIdStr.endsWith(IdUtil.SDF.format(new Date(ts)) + uuid.toString()));
}
 

public static String getUniqueAndroidDeviceId(Context context){
  final TelephonyManager tm=(TelephonyManager)context.getSystemService(Context.TELEPHONY_SERVICE);
  String tmDevice, tmSerial, androidId=null;
  try {
    tmDevice="" + tm.getDeviceId();
    tmSerial=tm.getSimSerialNumber() != null ? tm.getSimSerialNumber() : "";
    androidId=android.provider.Settings.Secure.getString(context.getContentResolver(),android.provider.Settings.Secure.ANDROID_ID);
    if (androidId == null) {
      return toSHA1(DeveloperConfiguration.apiKey);
    }
 else     if (androidId.equals(BUGGED_ANDROID_ID) && ("000000000000000".equals(tmDevice))) {
      return toSHA1(DeveloperConfiguration.apiKey);
    }
 else     if ((androidId.equals(BUGGED_ANDROID_ID)) && (tmSerial.equals(""))) {
      return null;
    }
 else {
      UUID deviceUuid=new UUID(androidId.hashCode(),((long)tmDevice.hashCode() << 32) | tmSerial.hashCode());
      String deviceId=deviceUuid.toString();
      return deviceId;
    }
  }
 catch (  Exception e) {
    return null;
  }
}
 

@Test public void uuids() throws Exception {
  Map<String,Object> data=new LinkedHashMap<String,Object>();
  data.put("Int32",5);
  data.put("Arr",Arrays.asList("a","b","c"));
  UUID uuid=UUID.randomUUID();
  data.put("Uuid",uuid);
  BSONObject obj=generateAndParse(data);
  assertEquals(5,obj.get("Int32"));
  assertNotNull(obj.get("Uuid"));
  assertEquals(UUID.class,obj.get("Uuid").getClass());
  assertEquals(uuid,obj.get("Uuid"));
}
 

@Test public void SerializingThenDeserializingReadingResultsInSameReading(){
  UUID uuid=UUID.randomUUID();
  DateTime date=new DateTime();
  Reading reading=new Reading(uuid,date,new BigDecimal(195).movePointLeft(1),24,"ESE",BigInteger.valueOf(17L),false);
  ByteBuffer buffer=serializer.toByteBuffer(reading);
  Reading deserializedReading=new Reading(uuid,date,(Reading)serializer.fromByteBuffer(buffer));
  assertEquals(reading,deserializedReading);
}
 

public List<PID> getNextPIDs(int howMany){
  List<PID> result=new ArrayList<PID>();
  for (int i=0; i < howMany; i++) {
    while (true) {
      UUID u=UUID.randomUUID();
      String s=String.format("uuid:%1$s",u);
      PID p=new PID(s);
      if (this.verifyUnique) {
        if (this.tripleStoreQueryService.verify(p) != null) {
          continue;
        }
      }
      result.add(p);
      break;
    }
  }
  return result;
}
 

/** 
 * Populates a RequestEvent from a servlet request.
 * @param request
 */
public RequestEvent(final HttpServletRequest request){
  this.id=new RequestEventId(UUID.randomUUID().toString());
  this.start=System.currentTimeMillis();
  this.method=HttpMethod.get(request.getMethod());
  this.uri=request.getRequestURI();
  this.queryString=request.getQueryString();
  this.ip=request.getRemoteAddr();
  this.userAgent=UserAgent.from(request.getHeader("User-Agent"));
}
 

public Metrics(final Plugin plugin) throws IOException {
  if (plugin == null) {
    throw new IllegalArgumentException("Plugin cannot be null");
  }
  this.plugin=plugin;
  configurationFile=new File(CONFIG_FILE);
  configuration=YamlConfiguration.loadConfiguration(configurationFile);
  configuration.addDefault("opt-out",false);
  configuration.addDefault("guid",UUID.randomUUID().toString());
  if (configuration.get("guid",null) == null) {
    configuration.options().header("http://mcstats.org").copyDefaults(true);
    configuration.save(configurationFile);
  }
  guid=configuration.getString("guid");
}
 

public StreamResource buildStreamResource(ProcessInstance processInstance,RepositoryService repositoryService,RuntimeService runtimeService){
  StreamResource imageResource=null;
  ProcessDefinitionEntity processDefinition=(ProcessDefinitionEntity)((RepositoryServiceImpl)repositoryService).getDeployedProcessDefinition(processInstance.getProcessDefinitionId());
  if (processDefinition != null && processDefinition.isGraphicalNotationDefined()) {
    InputStream definitionImageStream=ProcessDiagramGenerator.generateDiagram(processDefinition,"png",runtimeService.getActiveActivityIds(processInstance.getId()));
    StreamSource streamSource=new InputStreamStreamSource(definitionImageStream);
    String imageExtension=extractImageExtension(processDefinition.getDiagramResourceName());
    String fileName=processInstance.getId() + UUID.randomUUID() + "."+ imageExtension;
    imageResource=new StreamResource(streamSource,fileName,ExplorerApp.get());
  }
  return imageResource;
}
 

protected void uploadTaskModel(StringBuilder taskModelsString,String baseFileName){
  Session session=getCmisSession();
  Folder modelFolder=(Folder)session.getObjectByPath(DATA_DICTIONARY_FOLDER);
  String taskModelFileName=baseFileName + "-task-model.xml";
  String taskModelId=UUID.randomUUID().toString();
  String taskModelXML=MessageFormat.format(getTaskModelTemplate(),taskModelId,taskModelsString.toString());
  LOGGER.info("Deploying task model XML:");
  prettyLogXml(taskModelXML);
  ByteArrayInputStream inputStream=new ByteArrayInputStream(taskModelXML.getBytes());
  ContentStream contentStream=new ContentStreamImpl(taskModelFileName,null,"application/xml",inputStream);
  Document taskModelDocument=getDocumentFromFolder(DATA_DICTIONARY_FOLDER,taskModelFileName);
  if (taskModelDocument == null) {
    HashMap<String,Object> properties=new HashMap<String,Object>();
    properties.put("cmis:name",taskModelFileName);
    properties.put("cmis:objectTypeId","D:cm:dictionaryModel");
    properties.put("cm:modelActive",true);
    LOGGER.info("Task model file : " + taskModelFileName);
    modelFolder.createDocument(properties,contentStream,VersioningState.MAJOR);
  }
 else {
    LOGGER.info("Updating content of " + taskModelFileName);
    taskModelDocument.setContentStream(contentStream,true);
  }
}
 

public Metrics(final Plugin plugin) throws IOException {
  if (plugin == null) {
    throw new IllegalArgumentException("Plugin cannot be null");
  }
  this.plugin=plugin;
  configurationFile=new File(CONFIG_FILE);
  configuration=YamlConfiguration.loadConfiguration(configurationFile);
  configuration.addDefault("opt-out",false);
  configuration.addDefault("guid",UUID.randomUUID().toString());
  if (configuration.get("guid",null) == null) {
    configuration.options().header("http://mcstats.org").copyDefaults(true);
    configuration.save(configurationFile);
  }
  guid=configuration.getString("guid");
}
 

public static AdContext getAdContext(HttpServletRequest request,HttpServletResponse response){
  AdContext context=new AdContext();
  String userID=null;
  Cookie cookie=CookieUtils.getCookie(request.getCookies(),AdServerConstants.Cookie.USERID);
  if (cookie != null) {
    userID=cookie.getValue();
  }
  if (Strings.isEmpty(userID)) {
    userID=UUID.randomUUID().toString();
    CookieUtils.addCookie(response,AdServerConstants.Cookie.USERID,userID,CookieUtils.ONE_YEAR,RuntimeContext.getProperties().getProperty(AdServerConstants.CONFIG.PROPERTIES.COOKIE_DOMAIN));
  }
  context.setUserid(userID);
  String requestID=(String)request.getParameter(RequestHelper.requestId);
  if (Strings.isEmpty(requestID)) {
    requestID=UUID.randomUUID().toString();
  }
  context.setRequestid(requestID);
  String slot=(String)request.getParameter(RequestHelper.slot);
  if (!Strings.isEmpty(slot)) {
    try {
      AdSlot aduuid=AdSlot.fromString(slot);
      context.setSlot(aduuid);
    }
 catch (    Exception e) {
      logger.error("",e);
    }
  }
  String clientIP=request.getRemoteAddr();
  if (request.getHeader("X-Real-IP") != null) {
    clientIP=request.getHeader("X-Real-IP");
  }
  context.setIp(clientIP);
  return context;
}
 

private File getTmpFile(String path){
  File file;
  do {
    file=new File(path + ".ahc" + UUID.randomUUID().toString().replace("-","").substring(0,16));
  }
 while (file.exists());
  return file;
}
 

public static BluetoothSocket createSocket(final BluetoothDevice device) throws IOException {
  BluetoothSocket socket=null;
  try {
    Method m=device.getClass().getMethod("createRfcommSocket",int.class);
    socket=(BluetoothSocket)m.invoke(device,1);
  }
 catch (  NoSuchMethodException ignore) {
    socket=device.createRfcommSocketToServiceRecord(UUID.fromString("00001101-0000-1000-8000-00805F9B34FB"));
  }
catch (  Exception ignore) {
  }
  return socket;
}
 

private int downloadManifest(){
  try {
    if (!NetworkUtils.isNetworkAvailable(mActivity)) {
      UiUtils.showToast(mActivity,"Please check your network connection");
      return -1;
    }
    DefaultHttpClient httpClient=new DefaultHttpClient();
    File manifest=new File(getCacheDir(),MANIFEST);
    boolean fetch=true;
    if (manifest.exists()) {
      Date now=new Date();
      long age=now.getTime() - manifest.lastModified();
      if (age < 10 * DateUtils.MINUTE_IN_MILLIS) {
        fetch=false;
      }
    }
    if (fetch) {
      NetworkUtils.doHttpGet(mActivity,httpClient,HOST,PORT,PATH + "/" + MANIFEST,"uuid=" + UUID.randomUUID().toString(),manifest);
    }
  }
 catch (  Exception e) {
    UiUtils.showToast(mActivity,e.getMessage());
    return -1;
  }
  return 0;
}
 

@Test public void testMTStress() throws InterruptedException, ExecutionException {
  ScheduledExecutorService executor=Executors.newScheduledThreadPool(10);
  List<Future<Void>> futures=new ArrayList<Future<Void>>();
  for (int loop=0; loop < 30; loop++) {
    futures.add(executor.submit(new Callable<Void>(){
      public Void call() throws Exception {
        for (int i=0; i < 10; i++) {
          doInTxn(new Action(){
            public void run(            BlobStoreConnection con) throws Exception {
              for (int j=0; j < 3; j++) {
                URI id=URI.create("urn:mt:" + UUID.randomUUID());
                byte[] buf=new byte[4096];
                Blob b;
                b=con.getBlob(id,null);
                OutputStream out;
                IOUtils.copyLarge(new ByteArrayInputStream(buf),out=b.openOutputStream(buf.length,true));
                out.close();
                InputStream in;
                assertEquals(buf,IOUtils.toByteArray(in=b.openInputStream()));
                in.close();
                b.delete();
              }
            }
          }
,true);
        }
        return null;
      }
    }
));
  }
  for (  Future<Void> res : futures)   res.get();
}
 

private static void writeInstallationFile(File installation) throws IOException {
  FileOutputStream out=new FileOutputStream(installation);
  String id=UUID.randomUUID().toString();
  out.write(id.getBytes());
  out.close();
}
 

/** 
 * Overridden to generate UUID and for versioning. Clones the descriptor and increases the sequenceNumber before saving.
 * @param card the card
 * @return the alpha card
 * @see org.appfuse.dao.hibernate.GenericDaoHibernate#save(java.lang.Object)
 */
@Override public AlphaCard save(final AlphaCard card){
  if (card.getAlphaCardIdentifier() != null) {
    if (card.getAlphaCardIdentifier().getCardId() == null) {
      card.getAlphaCardIdentifier().setCardId(UUID.randomUUID().toString());
    }
 else {
      this.getHibernateTemplate().flush();
      this.getHibernateTemplate().evict(card);
      this.getHibernateTemplate().clear();
    }
    card.setAlphaCardDescriptor(card.getAlphaCardDescriptor().clone());
    final Long newSequenceNumber=this.getLastValue() + 1L;
    card.getAlphaCardIdentifier().setSequenceNumber(newSequenceNumber);
    card.getAlphaCardDescriptor().getAlphaCardIdentifier().setSequenceNumber(newSequenceNumber);
  }
  return super.save(card);
}
 

public static ProtectionSpecificHeader createFor(UUID systemId,ByteBuffer bufferWrapper){
  final Class<? extends ProtectionSpecificHeader> aClass=uuidRegistry.get(systemId);
  ProtectionSpecificHeader protectionSpecificHeader=new ProtectionSpecificHeader();
  if (aClass != null) {
    try {
      protectionSpecificHeader=aClass.newInstance();
    }
 catch (    InstantiationException e) {
      throw new RuntimeException(e);
    }
catch (    IllegalAccessException e) {
      throw new RuntimeException(e);
    }
  }
  protectionSpecificHeader.parse(bufferWrapper);
  return protectionSpecificHeader;
}
 

public ClientSocketThread(String device,Handler handle){
  mMACAddres=device.substring(device.lastIndexOf('\n') + 1,device.lastIndexOf(":")).toUpperCase();
  mHandle=handle;
  try {
    mRemoteDevice=mBluetoothAdapter.getRemoteDevice(mMACAddres);
    mSocket=mRemoteDevice.createRfcommSocketToServiceRecord(UUID.fromString(DEV_UUID));
  }
 catch (  IllegalArgumentException e) {
    mSocket=null;
    Message msg=new Message();
    msg.obj=e.getMessage();
    mHandle.sendEmptyMessage(DIALOG_CANCEL);
  }
catch (  IOException e) {
    Message msg=new Message();
    msg.obj=e.getMessage();
    mHandle.sendEmptyMessage(DIALOG_CANCEL);
  }
}
 

public static String getDeviceId(){
  String value=getStringSetting(Setting.STR_DEVICEID);
  if (value == null) {
    String newDeviceId=UUID.randomUUID().toString().replace("-","");
    addStringSetting(Setting.STR_DEVICEID,newDeviceId);
    return newDeviceId;
  }
  return value;
}
 

String addFile(final InputStream stream){
  String guid=UUID.randomUUID().toString();
  String path=savaFile(guid,stream);
  application.getDatabase().addFile(guid,path);
  return guid;
}
 

private String openNewWindow(String iInitialCommand){
  TermService service=mTermService;
  String initialCommand=mSettings.getInitialCommand();
  if (iInitialCommand != null) {
    if (initialCommand != null) {
      initialCommand+="\r" + iInitialCommand;
    }
 else {
      initialCommand=iInitialCommand;
    }
  }
  TermSession session=Term.createTermSession(this,mSettings,initialCommand);
  session.setFinishCallback(service);
  service.getSessions().add(session);
  String handle=UUID.randomUUID().toString();
  ((ShellTermSession)session).setHandle(handle);
  Intent intent=new Intent(PRIVACT_OPEN_NEW_WINDOW);
  intent.addCategory(Intent.CATEGORY_DEFAULT);
  intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
  startActivity(intent);
  return handle;
}
 

private static void writeInstallationFile(File installation) throws IOException {
  FileOutputStream out=new FileOutputStream(installation);
  String id=UUID.randomUUID().toString();
  out.write(id.getBytes());
  out.close();
}
 

public AdvertisedService(ServiceReference ref){
  Assert.isNotNull(ref);
  this.serviceReference=ref;
  this.uuid=UUID.randomUUID().toString();
  String services[]=(String[])this.serviceReference.getProperty(Constants.OBJECTCLASS);
  for (  String k : this.serviceReference.getPropertyKeys()) {
    Object value=this.serviceReference.getProperty(k);
    if (value instanceof String && ((String)value).contains("localhost")) {
      this.properties.put(k,((String)value).replace("localhost",Geo.getHost()));
      continue;
    }
    this.properties.put(k,this.serviceReference.getProperty(k));
  }
  IServiceTypeID serviceTypeID=ServiceIDFactory.getDefault().createServiceTypeID(DiscoveryContainer.getSingleton().getConnectNamespace(),services,IServiceTypeID.DEFAULT_PROTO);
  serviceTypeID=new ZooServiceTypeID((DiscoveryNamespace)DiscoveryContainer.getSingleton().getConnectNamespace(),serviceTypeID,this.serviceReference.getProperty(Constants.SERVICE_ID).toString());
  serviceID=new ZooServiceID(DiscoveryContainer.getSingleton().getConnectNamespace(),serviceTypeID,Geo.getLocation());
  super.properties=new ServiceProperties(this.properties);
  this.properties.put(Constants.OBJECTCLASS,arrayToString(services));
  this.properties.put(LOCATION,Geo.getLocation());
  this.properties.put(WEIGHT,getWeight());
  this.properties.put(PRIORITY,getPriority());
  this.properties.put(NODE_PROPERTY_NAME_PROTOCOLS,arrayToString(IServiceTypeID.DEFAULT_PROTO));
  this.properties.put(NODE_PROPERTY_NAME_SCOPE,arrayToString(IServiceTypeID.DEFAULT_SCOPE));
  this.properties.put(NODE_PROPERTY_NAME_NA,IServiceTypeID.DEFAULT_NA);
  publishedServices.put(serviceTypeID.getInternal(),this);
}
 

private static ParameterizedTypeHandlerMap<JsonSerializer<?>> createDefaultSerializers(){
  ParameterizedTypeHandlerMap<JsonSerializer<?>> map=new ParameterizedTypeHandlerMap<JsonSerializer<?>>();
  map.register(URL.class,URL_TYPE_ADAPTER);
  map.register(URI.class,URI_TYPE_ADAPTER);
  map.register(UUID.class,UUUID_TYPE_ADAPTER);
  map.register(Locale.class,LOCALE_TYPE_ADAPTER);
  map.register(Date.class,DATE_TYPE_ADAPTER);
  map.register(java.sql.Date.class,JAVA_SQL_DATE_TYPE_ADAPTER);
  map.register(Timestamp.class,DATE_TYPE_ADAPTER);
  map.register(Time.class,TIME_TYPE_ADAPTER);
  map.register(Calendar.class,GREGORIAN_CALENDAR_TYPE_ADAPTER);
  map.register(GregorianCalendar.class,GREGORIAN_CALENDAR_TYPE_ADAPTER);
  map.register(BigDecimal.class,BIG_DECIMAL_TYPE_ADAPTER);
  map.register(BigInteger.class,BIG_INTEGER_TYPE_ADAPTER);
  map.register(BitSet.class,BIT_SET_ADAPTER);
  map.register(Boolean.class,BOOLEAN_TYPE_ADAPTER);
  map.register(boolean.class,BOOLEAN_TYPE_ADAPTER);
  map.register(Byte.class,BYTE_TYPE_ADAPTER);
  map.register(byte.class,BYTE_TYPE_ADAPTER);
  map.register(Character.class,CHARACTER_TYPE_ADAPTER);
  map.register(char.class,CHARACTER_TYPE_ADAPTER);
  map.register(Integer.class,INTEGER_TYPE_ADAPTER);
  map.register(int.class,INTEGER_TYPE_ADAPTER);
  map.register(Number.class,NUMBER_TYPE_ADAPTER);
  map.register(Short.class,SHORT_TYPE_ADAPTER);
  map.register(short.class,SHORT_TYPE_ADAPTER);
  map.register(String.class,STRING_TYPE_ADAPTER);
  map.register(StringBuilder.class,STRING_BUILDER_TYPE_ADAPTER);
  map.register(StringBuffer.class,STRING_BUFFER_TYPE_ADAPTER);
  map.makeUnmodifiable();
  return map;
}
 

public ConnectionService(){
  mSelf=this;
  mBtAdapter=BluetoothAdapter.getDefaultAdapter();
  mApp="";
  mBtSockets=new HashMap<String,BluetoothSocket>();
  mBtDeviceAddresses=new ArrayList<String>();
  mBtStreamWatcherThreads=new HashMap<String,Thread>();
  mUuid=new ArrayList<UUID>();
  mUuid.add(UUID.fromString("a60f35f0-b93a-11de-8a39-08002009c666"));
  mUuid.add(UUID.fromString("503c7430-bc23-11de-8a39-0800200c9a66"));
  mUuid.add(UUID.fromString("503c7431-bc23-11de-8a39-0800200c9a66"));
  mUuid.add(UUID.fromString("503c7432-bc23-11de-8a39-0800200c9a66"));
  mUuid.add(UUID.fromString("503c7433-bc23-11de-8a39-0800200c9a66"));
  mUuid.add(UUID.fromString("503c7434-bc23-11de-8a39-0800200c9a66"));
  mUuid.add(UUID.fromString("503c7435-bc23-11de-8a39-0800200c9a66"));
}
 

protected Map referenceData(HttpServletRequest httpServletRequest) throws Exception {
  Map<String,Object> map=new HashMap<String,Object>();
  map.put("captchaString",UUID.randomUUID().toString());
  map.put("captchaEnabled",captchaEnabled);
  return map;
}
 

private String makeRecordId(){
  StringBuilder recID=new StringBuilder();
  recID.append("<").append(SCHEME_COLON);
  recID.append(UUID.randomUUID().toString());
  recID.append(">");
  return recID.toString();
}
 

public String saveState(){
  String branch=UUID.randomUUID().toString();
  git.createBranch(branch.toString());
  lastSavedState=branch;
  return branch;
}
 

public ProtocolMetaData deploy(final Archive<?> archive) throws DeploymentException {
  try {
    StandardContext standardContext=archive.as(ShrinkWrapStandardContext.class);
    standardContext.addLifecycleListener(new EmbeddedContextConfig());
    standardContext.setUnpackWAR(configuration.isUnpackArchive());
    standardContext.setJ2EEServer("Arquillian-" + UUID.randomUUID().toString());
    standardContext.setParentClassLoader(Thread.currentThread().getContextClassLoader());
    if (standardContext.getUnpackWAR()) {
      deleteUnpackedWAR(standardContext);
    }
    WebappLoader webappLoader=new WebappLoader(standardContext.getParentClassLoader());
    webappLoader.setDelegate(standardContext.getDelegate());
    webappLoader.setLoaderClass(EmbeddedWebappClassLoader.class.getName());
    standardContext.setLoader(webappLoader);
    standardHost.addChild(standardContext);
    standardContextProducer.set(standardContext);
    String contextPath=standardContext.getPath();
    HTTPContext httpContext=new HTTPContext(bindAddress,bindPort);
    for (    String mapping : standardContext.findServletMappings()) {
      httpContext.add(new Servlet(standardContext.findServletMapping(mapping),contextPath));
    }
    return new ProtocolMetaData().addContext(httpContext);
  }
 catch (  Exception e) {
    throw new DeploymentException("Failed to deploy " + archive.getName(),e);
  }
}
 

public void createRuntime(@Observes BeforeSuite event) throws Exception {
  IRuntime runtime=ArquillianRuntime.getInstance();
  runtime.setSessionId(UUID.randomUUID().toString());
  runtime.startup();
  runtimeInst.set(runtime);
}
 

public ProtocolMetaData deploy(final Archive<?> archive) throws DeploymentException {
  try {
    StandardContext standardContext=archive.as(ShrinkWrapStandardContext.class);
    standardContext.addLifecycleListener(new EmbeddedContextConfig());
    standardContext.setUnpackWAR(configuration.isUnpackArchive());
    standardContext.setJ2EEServer("Arquillian-" + UUID.randomUUID().toString());
    standardContext.setParentClassLoader(Thread.currentThread().getContextClassLoader());
    if (standardContext.getUnpackWAR()) {
      deleteUnpackedWAR(standardContext);
    }
    WebappLoader webappLoader=new WebappLoader(standardContext.getParentClassLoader());
    webappLoader.setDelegate(standardContext.getDelegate());
    webappLoader.setLoaderClass(EmbeddedWebappClassLoader.class.getName());
    standardContext.setLoader(webappLoader);
    standardHost.addChild(standardContext);
    standardContextProducer.set(standardContext);
    String contextPath=standardContext.getPath();
    HTTPContext httpContext=new HTTPContext(bindAddress,bindPort);
    for (    String mapping : standardContext.findServletMappings()) {
      httpContext.add(new Servlet(standardContext.findServletMapping(mapping),contextPath));
    }
    return new ProtocolMetaData().addContext(httpContext);
  }
 catch (  Exception e) {
    throw new DeploymentException("Failed to deploy " + archive.getName(),e);
  }
}
 

@Override public AuthorizationResponse authorizePayment(AuthorizationRequest authorizationRequest){
  AuthorizationResponse authorizationResponse=new AuthorizationResponse();
  String someId=UUID.randomUUID().toString();
  if (!VALID_CARD_NUMBERS.contains(authorizationRequest.getCreditCard().getCardNumber())) {
    authorizationResponse.setSuccess(Boolean.FALSE);
    authorizationResponse.setMessage("Declined");
    return authorizationResponse;
  }
 else {
    authorizationResponse.setSuccess(true);
    authorizationResponse.setTransactionId(someId);
  }
  if (authorizationRequest.getStoreCard()) {
    org.fracturedatlas.athena.payments.model.CreditCard card=authorizationRequest.getCreditCard();
    String token=UUID.randomUUID().toString();
    card.setToken(token);
    card.setId(token);
    cards.put(card.getId(),card);
    authorizationResponse.setCreditCard(card);
    org.fracturedatlas.athena.payments.model.Customer customer=authorizationRequest.getCustomer();
    String customerId=UUID.randomUUID().toString();
    customer.setId(customerId);
    customers.put(customer.getId(),customer);
    authorizationResponse.setCustomer(customer);
  }
  authorizationResponse.setMessage("Success");
  return authorizationResponse;
}
 

public static String encrypt(String encryption,String toencrypt) throws NoSuchAlgorithmException, UnsupportedEncodingException {
  if (encryption.equalsIgnoreCase("md5")) {
    return md5(toencrypt);
  }
 else   if (encryption.equalsIgnoreCase("sha1") || encryption.equalsIgnoreCase("sha-1")) {
    return SHA1(toencrypt);
  }
 else   if (encryption.equalsIgnoreCase("sha256") || encryption.equalsIgnoreCase("sha-256")) {
    return SHA256(toencrypt);
  }
 else   if (encryption.equalsIgnoreCase("sha512") || encryption.equalsIgnoreCase("sha2") || encryption.equalsIgnoreCase("sha-512")|| encryption.equalsIgnoreCase("sha-2")) {
    return SHA512(toencrypt);
  }
 else   if (encryption.equalsIgnoreCase("whirlpool")) {
    return whirlpool(toencrypt);
  }
 else   if (encryption.equalsIgnoreCase("xauth")) {
    String salt=whirlpool(UUID.randomUUID().toString()).substring(0,12);
    String hash=whirlpool(salt + toencrypt);
    int saltPos=(toencrypt.length() >= hash.length() ? hash.length() - 1 : toencrypt.length());
    return hash.substring(0,saltPos) + salt + hash.substring(saltPos);
  }
  if (Config.debug_enable) {
    Util.logging.Info("Could not find encryption method: " + encryption + ", using default: md5");
  }
  Config.custom_encryption="md5";
  return md5(toencrypt);
}
 

public Metrics() throws IOException {
  File file=new File(CONFIG_FILE);
  configuration=YamlConfiguration.loadConfiguration(file);
  configuration.addDefault("opt-out",false);
  configuration.addDefault("guid",UUID.randomUUID().toString());
  if (configuration.get("guid",null) == null) {
    configuration.options().header("http://metrics.griefcraft.com").copyDefaults(true);
    configuration.save(file);
  }
  guid=configuration.getString("guid");
}
 

private static byte[] generateSync(){
  try {
    MessageDigest digester=MessageDigest.getInstance("MD5");
    long time=System.currentTimeMillis();
    digester.update((UUID.randomUUID() + "@" + time).getBytes());
    return digester.digest();
  }
 catch (  NoSuchAlgorithmException e) {
    throw new RuntimeException(e);
  }
}
 

public static File generateTempBaseDir(){
  String tempDir=System.getProperty("java.io.tmpdir");
  File f=new File(tempDir + File.separator + UUID.randomUUID().toString());
  f.mkdir();
  return f;
}
 

/** 
 * Bootstraps the current account preferences for new customers or customers migrating from the legacy single-account preference
 */
private void bootstrapAccountPreferences(){
  String currentAccount=getPreferenceStore().getString(PreferenceConstants.P_CURRENT_ACCOUNT);
  if (currentAccount == null || currentAccount.length() == 0) {
    String accountId=UUID.randomUUID().toString();
    getPreferenceStore().putValue(PreferenceConstants.P_CURRENT_ACCOUNT,accountId);
    getPreferenceStore().putValue(PreferenceConstants.P_ACCOUNT_IDS,accountId);
    getPreferenceStore().putValue(accountId + ":" + PreferenceConstants.P_ACCOUNT_NAME,PreferenceConstants.DEFAULT_ACCOUNT_NAME_BASE_64);
    for (    String prefName : new String[]{PreferenceConstants.P_ACCESS_KEY,PreferenceConstants.P_CERTIFICATE_FILE,PreferenceConstants.P_PRIVATE_KEY_FILE,PreferenceConstants.P_SECRET_KEY,PreferenceConstants.P_USER_ID}) {
      convertExistingPreference(accountId,prefName);
    }
  }
}
 

public static Props produceParentProperties(final ExecutableFlow flow){
  Props parentProps=new Props();
  parentProps.put("azkaban.flow.id",flow.getId());
  parentProps.put("azkaban.flow.uuid",UUID.randomUUID().toString());
  DateTime loadTime=new DateTime();
  parentProps.put("azkaban.flow.start.timestamp",loadTime.toString());
  parentProps.put("azkaban.flow.start.year",loadTime.toString("yyyy"));
  parentProps.put("azkaban.flow.start.month",loadTime.toString("MM"));
  parentProps.put("azkaban.flow.start.day",loadTime.toString("dd"));
  parentProps.put("azkaban.flow.start.hour",loadTime.toString("HH"));
  parentProps.put("azkaban.flow.start.minute",loadTime.toString("mm"));
  parentProps.put("azkaban.flow.start.seconds",loadTime.toString("ss"));
  parentProps.put("azkaban.flow.start.milliseconds",loadTime.toString("SSS"));
  parentProps.put("azkaban.flow.start.timezone",loadTime.toString("ZZZZ"));
  return parentProps;
}
 

public final void store(Player player,World world,BackpackInventory toStore){
  if (player == null || world == null) {
    return;
  }
  HashMap<UUID,BackpackInventory> playerMap=BACKPACKS.get(world.getUID());
  if (playerMap == null) {
    playerMap=new HashMap<UUID,BackpackInventory>();
  }
  if (playerMap.containsKey(player.getUniqueId()) && toStore == null) {
    playerMap.remove(player.getUniqueId());
    BACKPACKS.put(world.getUID(),playerMap);
    return;
  }
  playerMap.put(player.getUniqueId(),toStore);
  BACKPACKS.put(world.getUID(),playerMap);
}
 

/** 
 * Prepares the unique UUID for this app installation. This actually means making UUID for the first time and saving this. The next time the UUID will be loaded from preferences.
 */
private void prepareUUID(){
  SharedPreferences pref=mContext.getSharedPreferences(PREF_TAG,Activity.MODE_PRIVATE);
  mUUID=pref.getString(PREF_UUID,"");
  if (mUUID.length() > 0) {
    return;
  }
  mUUID=UUID.randomUUID().toString();
  ;
  SharedPreferences.Editor editor=pref.edit();
  editor.putString(PREF_UUID,mUUID);
  editor.commit();
}
 

public static FileNamingMode toMode(String str){
  try {
    return valueOf(str);
  }
 catch (  Exception ex) {
    return UUID;
  }
}
 

private static Boolean configExists(){
  config.addDefault("usage.opt-out",false);
  config.addDefault("usage.guid",UUID.randomUUID().toString());
  if (!configFile.exists()) {
    try {
      config.options().copyDefaults(true);
      config.save(configFile);
    }
 catch (    Exception ex) {
      logger.log(Level.SEVERE,"Error with config file!");
      logger.log(Level.SEVERE,"",ex);
      return false;
    }
  }
  return true;
}
 

public static Trans getTrans(final Configuration conf,final String transXml,boolean singleThreaded) throws KettleException {
  initKettleEnvironment(conf);
  TransConfiguration transConfiguration=TransConfiguration.fromXML(transXml);
  TransMeta transMeta=transConfiguration.getTransMeta();
  String carteObjectId=UUID.randomUUID().toString();
  SimpleLoggingObject servletLoggingObject=new SimpleLoggingObject("HADOOP_MAPPER",LoggingObjectType.CARTE,null);
  servletLoggingObject.setContainerObjectId(carteObjectId);
  TransExecutionConfiguration executionConfiguration=transConfiguration.getTransExecutionConfiguration();
  servletLoggingObject.setLogLevel(executionConfiguration.getLogLevel());
  if (singleThreaded) {
    transMeta.setTransformationType(TransformationType.SingleThreaded);
    transMeta.setUsingThreadPriorityManagment(false);
  }
 else {
    transMeta.setTransformationType(TransformationType.Normal);
  }
  return new Trans(transMeta,servletLoggingObject);
}
 

/** 
 * Repository UUID. Lazy computed and cached.
 */
public UUID getUUID(AbstractProject context) throws SVNException {
  if (repositoryUUID == null || repositoryRoot == null) {
synchronized (this) {
      SVNRepository r=openRepository(context);
      r.testConnection();
      repositoryUUID=UUID.fromString(r.getRepositoryUUID(false));
      repositoryRoot=r.getRepositoryRoot(false);
    }
  }
  return repositoryUUID;
}
 

public Metrics(final Plugin plugin) throws IOException {
  if (plugin == null) {
    throw new IllegalArgumentException("Plugin cannot be null");
  }
  this.plugin=plugin;
  configurationFile=getConfigFile();
  configuration=YamlConfiguration.loadConfiguration(configurationFile);
  configuration.addDefault("opt-out",false);
  configuration.addDefault("guid",UUID.randomUUID().toString());
  if (configuration.get("guid",null) == null) {
    configuration.options().header("http://mcstats.org").copyDefaults(true);
    configuration.save(configurationFile);
  }
  guid=configuration.getString("guid");
}
 

private String addMessageID(SOAPHeader header) throws HeaderProcessingException {
  try {
    String id=null;
    if (fProperties.containsKey(WSA_TAG_MESSAGE_ID)) {
      id=fProperties.get(WSA_TAG_MESSAGE_ID);
    }
 else {
      id=WSA_MESSAGE_ID_PREFIX + UUID.randomUUID().toString();
    }
    SOAPElement msgId=header.addChildElement(wsaQName(WSA_TAG_MESSAGE_ID));
    msgId.setTextContent(id);
    return id;
  }
 catch (  SOAPException e) {
    throw new HeaderProcessingException("Could not add MessageID header to outgoing SOAP message.",e);
  }
}
 

private void processUploads(){
  final BrixNode parentNode=getModelObject();
  for (  final FileUpload upload : uploads) {
    final String fileName=upload.getClientFileName();
    if (parentNode.hasNode(fileName)) {
      if (overwrite) {
        parentNode.getNode(fileName).remove();
      }
 else {
class ModelObject implements Serializable {
          @SuppressWarnings("unused") private String fileName=upload.getClientFileName();
        }
        getSession().error(getString("fileExists",new Model<ModelObject>(new ModelObject())));
        continue;
      }
    }
    BrixNode newNode=(BrixNode)parentNode.addNode(fileName,"nt:file");
    try {
      File temp=File.createTempFile(Brix.NS + "-upload-" + UUID.randomUUID().toString(),null);
      Streams.copy(upload.getInputStream(),new FileOutputStream(temp));
      upload.closeStreams();
      String mime=upload.getContentType();
      BrixFileNode file=BrixFileNode.initialize(newNode,mime);
      file.setData(file.getSession().getValueFactory().createBinary(new FileInputStream(temp)));
      file.getParent().save();
    }
 catch (    IOException e) {
      throw new IllegalStateException(e);
    }
  }
  SitePlugin.get().selectNode(this,parentNode,true);
}
 

/** 
 * Connect to a Bluetooth device with the given address and UUID.
 * @param addr string representation of MAC address of the Bluetooth device
 * @param uuid UUID of the Bluetooth device
 * @throws IOException
 */
public synchronized void connect(String addr,UUID uuid) throws IOException {
  cancelThreads();
  BluetoothDevice device=btAdapter.getRemoteDevice(addr);
  connectThread=new ConnectThread(device,uuid);
  connectThread.start();
  setState(State.CONNECTING);
}
 

public Metrics(final Plugin plugin) throws IOException {
  if (plugin == null) {
    throw new IllegalArgumentException("Plugin cannot be null");
  }
  this.plugin=plugin;
  this.configurationFile=this.getConfigFile();
  this.configuration=YamlConfiguration.loadConfiguration(this.configurationFile);
  this.configuration.addDefault("opt-out",false);
  this.configuration.addDefault("guid",UUID.randomUUID().toString());
  if (this.configuration.get("guid",null) == null) {
    this.configuration.options().header("http://mcstats.org").copyDefaults(true);
    this.configuration.save(this.configurationFile);
  }
  this.guid=this.configuration.getString("guid");
}
 

public void addView(WebView view){
synchronized (syncObject) {
    String u=UUID.randomUUID().toString();
    map.put(u,view);
  }
}
 

@Test public void crlNumberWithCert() throws Exception {
  X509V2CRLGenerator g=new X509V2CRLGenerator();
  g.setIssuerDN(new X500Principal("CN=test, UID=" + UUID.randomUUID()));
  g.setThisUpdate(new Date());
  g.setNextUpdate(Util.tomorrow());
  g.setSignatureAlgorithm("SHA1withRSA");
  g.addExtension(X509Extensions.CRLNumber,false,new CRLNumber(BigInteger.TEN));
  X509CRL x509crl=g.generate(KP.getPrivate());
  assertEquals(BigInteger.TEN,this.generator.getCRLNumber(x509crl));
}
 

public List<TaskHandle> add(Transaction transaction,Iterable<TaskOptions> taskOptionses){
  final ServletExecutorProducer producer=new ServletExecutorProducer();
  try {
    final List<TaskHandle> handles=new ArrayList<TaskHandle>();
    for (    TaskOptions to : taskOptionses) {
      TaskOptions copy=null;
      final TaskOptions.Method m=getMethod.invoke(to);
      if (m == TaskOptions.Method.PULL) {
        copy=new TaskOptions(to);
        String taskName=getTaskName.invoke(to);
        if (taskName == null) {
          taskName=UUID.randomUUID().toString();
          copy.taskName(taskName);
        }
        Long lifespan=getEtaMillis.invoke(to);
        RetryOptions retryOptions=getRetryOptions.invoke(to);
        getTasks().put(taskName,new TaskOptionsEntity(taskName,queueName,copy.getTag(),lifespan,copy,retryOptions),lifespan,TimeUnit.MILLISECONDS);
      }
 else       if (m == TaskOptions.Method.POST) {
        final MessageCreator mc=createMessageCreator(to);
        final String id=producer.sendMessage(mc);
        copy=new TaskOptions(to);
        if (getTaskName.invoke(to) == null)         copy.taskName(toTaskName(id));
      }
      if (copy != null)       handles.add(new TaskHandle(copy,getQueueName()));
    }
    return handles;
  }
 catch (  Exception e) {
    throw new RuntimeException(e);
  }
 finally {
    producer.dispose();
  }
}
 

protected String storeBytesInternal(String mimeType,ByteBuffer buffer) throws IOException {
  String key=UUID.randomUUID().toString();
  File file=new File(getDataDir(),key);
  FileOutputStream fos=new FileOutputStream(file);
  try {
    while (buffer.hasRemaining())     fos.write(buffer.get());
    fos.flush();
  }
  finally {
    fos.close();
  }
  return key;
}
 

static String loadMqSystemUsername(Properties properties){
  String s=loadString(properties,MQ_SYSTEM_USERNAME,StringUtils.EMPTY);
  if (StringUtils.isBlank(s)) {
    s="systemuser_" + UUID.randomUUID().toString();
  }
  return s;
}