nus-yam/ex-repair huggingface dataset:
Program: 14789
Project: 14789
Buggy source:
public CreateAccountResponseType createAccount(CreateAccountType request) throws EucalyptusCloudException {
  CreateAccountResponseType reply=request.getReply();
  reply.getResponseMetadata().setRequestId(reply.getCorrelationId());
  Context ctx=Contexts.lookup();
  User requestUser=ctx.getUser();
  try {
    Account newAccount=Privileged.createAccount(ctx.hasAdministrativePrivileges(),request.getAccountName(),null,null);
    AccountType account=reply.getCreateAccountResult().getAccount();
    account.setAccountName(newAccount.getName());
    account.setAccountId(newAccount.getAccountNumber());
  }
 catch (  Exception e) {
    LOG.error(e,e);
    if (e instanceof AuthException) {
      if (AuthException.ACCESS_DENIED.equals(e.getMessage())) {
        throw new EuareException(HttpResponseStatus.FORBIDDEN,EuareException.NOT_AUTHORIZED,"String_Node_Str" + requestUser.getName());
      }
 else       if (AuthException.ACCOUNT_ALREADY_EXISTS.equals(e.getMessage())) {
        throw new EuareException(HttpResponseStatus.CONFLICT,EuareException.ENTITY_ALREADY_EXISTS,"String_Node_Str" + request.getAccountName() + "String_Node_Str");
      }
 else       if (AuthException.INVALID_NAME.equals(e.getMessage())) {
        throw new EuareException(HttpResponseStatus.BAD_REQUEST,EuareException.INVALID_NAME,"String_Node_Str" + request.getAccountName());
      }
    }
    throw new EucalyptusCloudException(e);
  }
  return reply;
}

Fixed version (ground truth):
public CreateAccountResponseType createAccount(CreateAccountType request) throws EucalyptusCloudException {
  CreateAccountResponseType reply=request.getReply();
  reply.getResponseMetadata().setRequestId(reply.getCorrelationId());
  Context ctx=Contexts.lookup();
  User requestUser=ctx.getUser();
  try {
    Account newAccount=Privileged.createAccount(ctx.hasAdministrativePrivileges(),request.getAccountName(),null,null,true);
    AccountType account=reply.getCreateAccountResult().getAccount();
    account.setAccountName(newAccount.getName());
    account.setAccountId(newAccount.getAccountNumber());
  }
 catch (  Exception e) {
    LOG.error(e,e);
    if (e instanceof AuthException) {
      if (AuthException.ACCESS_DENIED.equals(e.getMessage())) {
        throw new EuareException(HttpResponseStatus.FORBIDDEN,EuareException.NOT_AUTHORIZED,"String_Node_Str" + requestUser.getName());
      }
 else       if (AuthException.ACCOUNT_ALREADY_EXISTS.equals(e.getMessage())) {
        throw new EuareException(HttpResponseStatus.CONFLICT,EuareException.ENTITY_ALREADY_EXISTS,"String_Node_Str" + request.getAccountName() + "String_Node_Str");
      }
 else       if (AuthException.INVALID_NAME.equals(e.getMessage())) {
        throw new EuareException(HttpResponseStatus.BAD_REQUEST,EuareException.INVALID_NAME,"String_Node_Str" + request.getAccountName());
      }
    }
    throw new EucalyptusCloudException(e);
  }
  return reply;
}
Program: 14790
Project: 14790
Buggy source:
public static Account createAccount(boolean hasAdministrativePrivilege,String accountName,String password,String email) throws AuthException {
  if (!hasAdministrativePrivilege) {
    throw new AuthException(AuthException.ACCESS_DENIED);
  }
  Account newAccount=Accounts.addAccount(accountName);
  Map<String,String> info=null;
  if (email != null) {
    info=Maps.newHashMap();
    info.put(User.EMAIL,email);
  }
  User admin=newAccount.addUser(User.ACCOUNT_ADMIN,"String_Node_Str",true,true,info);
  admin.resetToken();
  admin.createConfirmationCode();
  if (password != null) {
    admin.setPassword(Crypto.generateHashedPassword(password));
    admin.setPasswordExpires(System.currentTimeMillis() + User.PASSWORD_LIFETIME);
  }
  return newAccount;
}

Fixed version (ground truth):
public static Account createAccount(boolean hasAdministrativePrivilege,String accountName,String password,String email,boolean skipRegistration) throws AuthException {
  if (!hasAdministrativePrivilege) {
    throw new AuthException(AuthException.ACCESS_DENIED);
  }
  Account newAccount=Accounts.addAccount(accountName);
  Map<String,String> info=null;
  if (email != null) {
    info=Maps.newHashMap();
    info.put(User.EMAIL,email);
  }
  User admin=newAccount.addUser(User.ACCOUNT_ADMIN,"String_Node_Str",skipRegistration,true,info);
  admin.resetToken();
  admin.createConfirmationCode();
  if (password != null) {
    admin.setPassword(Crypto.generateHashedPassword(password));
    admin.setPasswordExpires(System.currentTimeMillis() + User.PASSWORD_LIFETIME);
  }
  return newAccount;
}
Program: 14791
Project: 14791
Buggy source:
public static User createAccount(String accountName,String password,String email){
  try {
    Account account=Privileged.createAccount(true,accountName,password,email);
    return account.lookupUserByName(User.ACCOUNT_ADMIN);
  }
 catch (  Exception e) {
    LOG.error("String_Node_Str" + accountName,e);
    LOG.debug(e,e);
    return null;
  }
}

Fixed version (ground truth):
public static String createAccount(User requestUser,String accountName,String password) throws EucalyptusServiceException {
  try {
    Account account=Privileged.createAccount(requestUser.isSystemAdmin(),accountName,password,null,true);
    return account.getAccountNumber();
  }
 catch (  Exception e) {
    LOG.error("String_Node_Str" + accountName,e);
    LOG.debug(e,e);
    throw new EucalyptusServiceException("String_Node_Str" + accountName + "String_Node_Str"+ e.getMessage());
  }
}
Program: 14792
Project: 14792
Buggy source:
@Override public void signupAccount(String accountName,String password,String email) throws EucalyptusServiceException {
  randomDelay();
  User admin=EuareWebBackend.createAccount(accountName,password,email);
  if (admin != null) {
    EuareWebBackend.notifyAccountRegistration(admin,accountName,email,ServletUtils.getRequestUrl(getThreadLocalRequest()));
  }
}

Fixed version (ground truth):
@Override public void signupAccount(String accountName,String password,String email) throws EucalyptusServiceException {
  randomDelay();
  User admin=EuareWebBackend.signupAccount(accountName,password,email);
  if (admin != null) {
    EuareWebBackend.notifyAccountRegistration(admin,accountName,email,ServletUtils.getRequestUrl(getThreadLocalRequest()));
  }
}
Program: 14793
Project: 14793
Buggy source:
public CreateAccountResponseType createAccount(CreateAccountType request) throws EucalyptusCloudException {
  CreateAccountResponseType reply=request.getReply();
  reply.getResponseMetadata().setRequestId(reply.getCorrelationId());
  Context ctx=Contexts.lookup();
  User requestUser=ctx.getUser();
  try {
    Account newAccount=Privileged.createAccount(ctx.hasAdministrativePrivileges(),request.getAccountName(),null,null);
    AccountType account=reply.getCreateAccountResult().getAccount();
    account.setAccountName(newAccount.getName());
    account.setAccountId(newAccount.getAccountNumber());
  }
 catch (  Exception e) {
    LOG.error(e,e);
    if (e instanceof AuthException) {
      if (AuthException.ACCESS_DENIED.equals(e.getMessage())) {
        throw new EuareException(HttpResponseStatus.FORBIDDEN,EuareException.NOT_AUTHORIZED,"String_Node_Str" + requestUser.getName());
      }
 else       if (AuthException.ACCOUNT_ALREADY_EXISTS.equals(e.getMessage())) {
        throw new EuareException(HttpResponseStatus.CONFLICT,EuareException.ENTITY_ALREADY_EXISTS,"String_Node_Str" + request.getAccountName() + "String_Node_Str");
      }
 else       if (AuthException.INVALID_NAME.equals(e.getMessage())) {
        throw new EuareException(HttpResponseStatus.BAD_REQUEST,EuareException.INVALID_NAME,"String_Node_Str" + request.getAccountName());
      }
    }
    throw new EucalyptusCloudException(e);
  }
  return reply;
}

Fixed version (ground truth):
public CreateAccountResponseType createAccount(CreateAccountType request) throws EucalyptusCloudException {
  CreateAccountResponseType reply=request.getReply();
  reply.getResponseMetadata().setRequestId(reply.getCorrelationId());
  Context ctx=Contexts.lookup();
  User requestUser=ctx.getUser();
  try {
    Account newAccount=Privileged.createAccount(ctx.hasAdministrativePrivileges(),request.getAccountName(),null,null,true);
    AccountType account=reply.getCreateAccountResult().getAccount();
    account.setAccountName(newAccount.getName());
    account.setAccountId(newAccount.getAccountNumber());
  }
 catch (  Exception e) {
    LOG.error(e,e);
    if (e instanceof AuthException) {
      if (AuthException.ACCESS_DENIED.equals(e.getMessage())) {
        throw new EuareException(HttpResponseStatus.FORBIDDEN,EuareException.NOT_AUTHORIZED,"String_Node_Str" + requestUser.getName());
      }
 else       if (AuthException.ACCOUNT_ALREADY_EXISTS.equals(e.getMessage())) {
        throw new EuareException(HttpResponseStatus.CONFLICT,EuareException.ENTITY_ALREADY_EXISTS,"String_Node_Str" + request.getAccountName() + "String_Node_Str");
      }
 else       if (AuthException.INVALID_NAME.equals(e.getMessage())) {
        throw new EuareException(HttpResponseStatus.BAD_REQUEST,EuareException.INVALID_NAME,"String_Node_Str" + request.getAccountName());
      }
    }
    throw new EucalyptusCloudException(e);
  }
  return reply;
}
Program: 14794
Project: 14794
Buggy source:
public static Account createAccount(boolean hasAdministrativePrivilege,String accountName,String password,String email) throws AuthException {
  if (!hasAdministrativePrivilege) {
    throw new AuthException(AuthException.ACCESS_DENIED);
  }
  Account newAccount=Accounts.addAccount(accountName);
  Map<String,String> info=null;
  if (email != null) {
    info=Maps.newHashMap();
    info.put(User.EMAIL,email);
  }
  User admin=newAccount.addUser(User.ACCOUNT_ADMIN,"String_Node_Str",true,true,info);
  admin.resetToken();
  admin.createConfirmationCode();
  if (password != null) {
    admin.setPassword(Crypto.generateHashedPassword(password));
    admin.setPasswordExpires(System.currentTimeMillis() + User.PASSWORD_LIFETIME);
  }
  return newAccount;
}

Fixed version (ground truth):
public static Account createAccount(boolean hasAdministrativePrivilege,String accountName,String password,String email,boolean skipRegistration) throws AuthException {
  if (!hasAdministrativePrivilege) {
    throw new AuthException(AuthException.ACCESS_DENIED);
  }
  Account newAccount=Accounts.addAccount(accountName);
  Map<String,String> info=null;
  if (email != null) {
    info=Maps.newHashMap();
    info.put(User.EMAIL,email);
  }
  User admin=newAccount.addUser(User.ACCOUNT_ADMIN,"String_Node_Str",skipRegistration,true,info);
  admin.resetToken();
  admin.createConfirmationCode();
  if (password != null) {
    admin.setPassword(Crypto.generateHashedPassword(password));
    admin.setPasswordExpires(System.currentTimeMillis() + User.PASSWORD_LIFETIME);
  }
  return newAccount;
}
Program: 14795
Project: 14795
Buggy source:
public static User createAccount(String accountName,String password,String email){
  try {
    Account account=Privileged.createAccount(true,accountName,password,email);
    return account.lookupUserByName(User.ACCOUNT_ADMIN);
  }
 catch (  Exception e) {
    LOG.error("String_Node_Str" + accountName,e);
    LOG.debug(e,e);
    return null;
  }
}

Fixed version (ground truth):
public static String createAccount(User requestUser,String accountName,String password) throws EucalyptusServiceException {
  try {
    Account account=Privileged.createAccount(requestUser.isSystemAdmin(),accountName,password,null,true);
    return account.getAccountNumber();
  }
 catch (  Exception e) {
    LOG.error("String_Node_Str" + accountName,e);
    LOG.debug(e,e);
    throw new EucalyptusServiceException("String_Node_Str" + accountName + "String_Node_Str"+ e.getMessage());
  }
}
Program: 14796
Project: 14796
Buggy source:
@Override public void signupAccount(String accountName,String password,String email) throws EucalyptusServiceException {
  randomDelay();
  User admin=EuareWebBackend.createAccount(accountName,password,email);
  if (admin != null) {
    EuareWebBackend.notifyAccountRegistration(admin,accountName,email,ServletUtils.getRequestUrl(getThreadLocalRequest()));
  }
}

Fixed version (ground truth):
@Override public void signupAccount(String accountName,String password,String email) throws EucalyptusServiceException {
  randomDelay();
  User admin=EuareWebBackend.signupAccount(accountName,password,email);
  if (admin != null) {
    EuareWebBackend.notifyAccountRegistration(admin,accountName,email,ServletUtils.getRequestUrl(getThreadLocalRequest()));
  }
}
Program: 14797
Project: 14797
Buggy source:
public static CheckException chainCheckExceptions(List<CheckException> exs){
  CheckException last=null;
  for (  CheckException ex : Lists.reverse(exs)) {
    if (last != null) {
      ex.addOtherException(ex);
    }
    last=ex;
  }
  return last;
}

Fixed version (ground truth):
public static CheckException chainCheckExceptions(final List<CheckException> exs){
  CheckException last=null;
  for (  final CheckException ex : Lists.reverse(exs)) {
    if (last != null) {
      ex.addOtherException(ex);
    }
    last=ex;
  }
  return last;
}
Program: 14798
Project: 14798
Buggy source:
private static CheckException newServiceCheckException(String correlationId,Severity severity,ServiceConfiguration config,Throwable t){
  if (t instanceof Error) {
    return new CheckException(correlationId,t,Severity.FATAL,config);
  }
 else   if (Severity.WARNING.ordinal() > severity.ordinal() && t instanceof RuntimeException) {
    return new CheckException(correlationId,t,Severity.WARNING,config);
  }
 else   if (t instanceof CheckException) {
    return new CheckException(correlationId,t,severity,config);
  }
 else {
    return new CheckException(correlationId,t,severity,config);
  }
}

Fixed version (ground truth):
private static CheckException newServiceCheckException(final String correlationId,final Severity severity,final ServiceConfiguration config,final Throwable t){
  if (t instanceof Error) {
    return new CheckException(correlationId,t,Severity.FATAL,config);
  }
 else   if ((Severity.WARNING.ordinal() > severity.ordinal()) && (t instanceof RuntimeException)) {
    return new CheckException(correlationId,t,Severity.WARNING,config);
  }
 else   if (t instanceof CheckException) {
    return new CheckException(correlationId,t,severity,config);
  }
 else {
    return new CheckException(correlationId,t,severity,config);
  }
}
Program: 14799
Project: 14799
Buggy source:
public static Function<ServiceStatusType,List<ServiceCheckRecord>> statusToEvents(final String correlationId){
  return new Function<ServiceStatusType,List<ServiceCheckRecord>>(){
    @Override public List<ServiceCheckRecord> apply(    ServiceStatusType input){
      List<ServiceCheckRecord> events=Lists.newArrayList();
      for (      CheckException ex : statusToCheckExceptions(correlationId).apply(input)) {
        events.add(new ServiceCheckRecord(ex));
      }
      return events;
    }
  }
;
}

Fixed version (ground truth):
public static Function<ServiceStatusType,List<ServiceCheckRecord>> statusToEvents(final String correlationId){
  return new Function<ServiceStatusType,List<ServiceCheckRecord>>(){
    @Override public List<ServiceCheckRecord> apply(    final ServiceStatusType input){
      final List<ServiceCheckRecord> events=Lists.newArrayList();
      for (      final CheckException ex : statusToCheckExceptions(correlationId).apply(input)) {
        events.add(new ServiceCheckRecord(ex));
      }
      return events;
    }
  }
;
}
Program: 14800
Project: 14800
Buggy source:
@Override public List<ServiceCheckRecord> apply(ServiceStatusType input){
  List<ServiceCheckRecord> events=Lists.newArrayList();
  for (  CheckException ex : statusToCheckExceptions(correlationId).apply(input)) {
    events.add(new ServiceCheckRecord(ex));
  }
  return events;
}

Fixed version (ground truth):
@Override public List<ServiceCheckRecord> apply(final ServiceStatusType input){
  final List<ServiceCheckRecord> events=Lists.newArrayList();
  for (  final CheckException ex : statusToCheckExceptions(correlationId).apply(input)) {
    events.add(new ServiceCheckRecord(ex));
  }
  return events;
}
Program: 14801
Project: 14801
Buggy source:
private CheckException(String correlationId,Throwable cause,Severity severity,ServiceConfiguration config){
  super(cause.getMessage());
  if (cause instanceof CheckException) {
    this.setStackTrace(cause.getStackTrace());
  }
 else {
    this.initCause(cause);
  }
  this.severity=severity;
  this.config=config;
  this.uuid=uuid(cause);
  this.correlationId=(correlationId == null ? this.uuid : correlationId);
  this.timestamp=new Date();
  this.eventState=config.lookupState();
  this.eventEpoch=Topology.epoch();
}

Fixed version (ground truth):
private CheckException(final String correlationId,final Throwable cause,final Severity severity,final ServiceConfiguration config){
  super(cause.getMessage());
  if (cause instanceof CheckException) {
    this.setStackTrace(cause.getStackTrace());
  }
 else {
    this.initCause(cause);
  }
  this.severity=severity;
  this.config=config;
  this.uuid=uuid(cause);
  this.correlationId=(correlationId == null ? this.uuid : correlationId);
  this.timestamp=new Date();
  this.eventState=config.lookupState();
  this.eventEpoch=Topology.epoch();
}
Program: 14802
Project: 14802
Buggy source:
private static Function<Throwable,CheckException> getExceptionMapper(final Severity severity,final ServiceConfiguration config){
  return new Function<Throwable,CheckException>(){
    @Override public CheckException apply(    Throwable input){
      return newServiceCheckException(severity,config,input);
    }
  }
;
}

Fixed version (ground truth):
private static Function<Throwable,CheckException> getExceptionMapper(final Severity severity,final ServiceConfiguration config){
  return new Function<Throwable,CheckException>(){
    @Override public CheckException apply(    final Throwable input){
      return newServiceCheckException(severity,config,input);
    }
  }
;
}
Program: 14803
Project: 14803
Buggy source:
@Override public boolean hasNext(){
  return this.curr != null && this.curr.other != null;
}

Fixed version (ground truth):
@Override public boolean hasNext(){
  return (this.curr != null) && (this.curr.other != null);
}
Program: 14804
Project: 14804
Buggy source:
private static String uuid(Throwable cause){
  if (cause != null && cause instanceof CheckException) {
    return ((CheckException)cause).getUuid();
  }
 else {
    return UUID.randomUUID().toString();
  }
}

Fixed version (ground truth):
private static String uuid(final Throwable cause){
  if ((cause != null) && (cause instanceof CheckException)) {
    return ((CheckException)cause).getUuid();
  }
 else {
    return UUID.randomUUID().toString();
  }
}
Program: 14805
Project: 14805
Buggy source:
public CheckException transform(ServiceConfiguration config,List<Throwable> ts){
  List<CheckException> exs=Lists.transform(ts,getExceptionMapper(this,config));
  CheckException last=chainCheckExceptions(exs);
  return last;
}

Fixed version (ground truth):
public CheckException transform(final ServiceConfiguration config,final List<Throwable> ts){
  final List<CheckException> exs=Lists.transform(ts,getExceptionMapper(this,config));
  final CheckException last=chainCheckExceptions(exs);
  return last;
}
Program: 14806
Project: 14806
Buggy source:
@Override public Iterator<CheckException> iterator(){
  return new Iterator<CheckException>(){
    CheckException curr;
{
      this.curr=CheckException.this.other;
    }
    @Override public boolean hasNext(){
      return this.curr != null && this.curr.other != null;
    }
    @Override public CheckException next(){
      return this.curr=this.curr.other;
    }
    @Override public void remove(){
      LOG.error("String_Node_Str");
    }
  }
;
}

Fixed version (ground truth):
@Override public Iterator<CheckException> iterator(){
  return new Iterator<CheckException>(){
    CheckException curr;
{
      this.curr=CheckException.this.other;
    }
    @Override public boolean hasNext(){
      return (this.curr != null) && (this.curr.other != null);
    }
    @Override public CheckException next(){
      return this.curr=this.curr.other;
    }
    @Override public void remove(){
      LOG.error("String_Node_Str");
    }
  }
;
}
Program: 14807
Project: 14807
Buggy source:
public static Function<ServiceStatusType,List<CheckException>> statusToCheckExceptions(final String correlationId){
  return new Function<ServiceStatusType,List<CheckException>>(){
    @Override public List<CheckException> apply(    ServiceStatusType input){
      List<CheckException> exs=Lists.newArrayList();
      for (      String detail : input.getDetails()) {
        ServiceConfiguration config=TypeMappers.transform(input.getServiceId(),ServiceConfiguration.class);
        CheckException ex=newServiceCheckException(correlationId,Severity.ERROR,config,new ServiceStateException(detail));
        exs.add(ex);
      }
      return exs;
    }
  }
;
}

Fixed version (ground truth):
public static Function<ServiceStatusType,List<CheckException>> statusToCheckExceptions(final String correlationId){
  return new Function<ServiceStatusType,List<CheckException>>(){
    @Override public List<CheckException> apply(    final ServiceStatusType input){
      final List<CheckException> exs=Lists.newArrayList();
      final ServiceConfiguration config=TypeMappers.transform(input.getServiceId(),ServiceConfiguration.class);
      final Component.State serviceState=Component.State.valueOf(input.getLocalState());
      final Component.State localState=config.lookupState();
      if (Component.State.ENABLED.equals(localState) && !localState.equals(serviceState)) {
        exs.add(newServiceCheckException(Severity.ERROR,config,new IllegalStateException("String_Node_Str" + localState + "String_Node_Str"+ serviceState)));
      }
      for (      final String detail : input.getDetails()) {
        final CheckException ex=newServiceCheckException(correlationId,Severity.ERROR,config,new ServiceStateException(detail));
        exs.add(ex);
      }
      return exs;
    }
  }
;
}
Program: 14808
Project: 14808
Buggy source:
public static ServiceCheckRecord createRecord(String correlationId,ServiceConfiguration config,Throwable t){
  return new ServiceCheckRecord(correlationId,Severity.ERROR.transform(config,t));
}

Fixed version (ground truth):
public static ServiceCheckRecord createRecord(final String correlationId,final ServiceConfiguration config,final Throwable t){
  return new ServiceCheckRecord(correlationId,Severity.ERROR.transform(config,t));
}
Program: 14809
Project: 14809
Buggy source:
CheckException addOtherException(CheckException e){
  if (this.other != null) {
    this.other.addOtherException(e);
    return this;
  }
 else {
    this.other=e;
    return this;
  }
}

Fixed version (ground truth):
CheckException addOtherException(final CheckException e){
  if (this.other != null) {
    this.other.addOtherException(e);
    return this;
  }
 else {
    this.other=e;
    return this;
  }
}
Program: 14810
Project: 14810
Buggy source:
public static URI internal(ComponentId compId,final InetAddress host,Integer port,String... pathParts){
  return make(compId,host,port,pathParts).get();
}

Fixed version (ground truth):
public static URI internal(ComponentId compId,final InetAddress host,Integer port,String... pathParts){
  return makeInternal(compId,host,port,pathParts).get();
}
Program: 14811
Project: 14811
Buggy source:
public static <I extends BaseMessage,O extends BaseMessage>void dispatch(final I request){
  ServiceConfiguration empyreanConfig=ServiceConfigurations.createEphemeral(Empyrean.INSTANCE);
  if (!serviceOperations.containsKey(request.getClass())) {
    try {
      ServiceContext.dispatch(RequestQueue.ENDPOINT,request);
    }
 catch (    Exception ex) {
      Contexts.responseError(request.getCorrelationId(),ex);
    }
  }
 else {
    try {
      final Context ctx=Contexts.lookup(request.getCorrelationId());
      final Function<I,O> op=(Function<I,O>)serviceOperations.get(request.getClass());
      Threads.enqueue(empyreanConfig,new Runnable(){
        @Override public void run(){
          Contexts.threadLocal(ctx);
          try {
            final O reply=op.apply(request);
            Contexts.response(reply);
          }
 catch (          final Exception ex) {
            Logs.extreme().error(ex,ex);
            Contexts.responseError(request.getCorrelationId(),ex);
          }
 finally {
            Contexts.removeThreadLocal();
          }
        }
      }
);
    }
 catch (    final Exception ex) {
      Logs.extreme().error(ex,ex);
      Contexts.responseError(request.getCorrelationId(),ex);
    }
  }
}

Fixed version (ground truth):
@SuppressWarnings("String_Node_Str") public static <I extends BaseMessage,O extends BaseMessage>void dispatch(final I request){
  if (!serviceOperations.containsKey(request.getClass())) {
    try {
      ServiceContext.dispatch(RequestQueue.ENDPOINT,request);
    }
 catch (    Exception ex) {
      Contexts.responseError(request.getCorrelationId(),ex);
    }
  }
 else {
    try {
      final Context ctx=Contexts.lookup(request.getCorrelationId());
      final Function<I,O> op=(Function<I,O>)serviceOperations.get(request.getClass());
      Timers.loggingWrapper(new Callable(){
        @Override public Object call() throws Exception {
          if (ASYNCHRONOUS) {
            Threads.enqueue(queueConfig.get(),new Runnable(){
              @Override public void run(){
                executeOperation(request,ctx,op);
              }
            }
);
          }
 else {
            executeOperation(request,ctx,op);
          }
          return null;
        }
      }
).call();
    }
 catch (    final Exception ex) {
      Logs.extreme().error(ex,ex);
      Contexts.responseError(request.getCorrelationId(),ex);
    }
  }
}
Program: 14812
Project: 14812
Buggy source:
@Override public void run(){
  Contexts.threadLocal(ctx);
  try {
    final O reply=op.apply(request);
    Contexts.response(reply);
  }
 catch (  final Exception ex) {
    Logs.extreme().error(ex,ex);
    Contexts.responseError(request.getCorrelationId(),ex);
  }
 finally {
    Contexts.removeThreadLocal();
  }
}

Fixed version (ground truth):
@Override public void run(){
  executeOperation(request,ctx,op);
}
Program: 14814
Project: 14814
Buggy source:
public Request<Q,R> execute(ServiceConfiguration config){
  this.doInitializeCallback(config);
  try {
    Logs.extreme().debug("String_Node_Str" + config);
    if (!this.handler.fire(config,this.request)) {
      LOG.error("String_Node_Str" + this.request);
      if (!this.requestResult.isDone()) {
        RequestException ex=new RequestException("String_Node_Str",this.getRequest());
        try {
          this.result.setException(ex);
        }
 catch (        Exception t) {
        }
      }
    }
 else {
      this.requestResult.get();
    }
  }
 catch (  Exception ex) {
    Exceptions.maybeInterrupted(ex);
    LOG.warn(ex);
    Logs.extreme().error(ex,ex);
    this.result.setException(ex);
    throw Exceptions.toUndeclared(ex);
  }
  return this;
}

Fixed version (ground truth):
public Request<Q,R> execute(ServiceConfiguration config){
  this.doInitializeCallback(config);
  try {
    Logs.extreme().debug("String_Node_Str" + config);
    if (!this.handler.fire(config,this.request)) {
      Logs.extreme().error("String_Node_Str" + this.request);
      if (!this.requestResult.isDone()) {
        RequestException ex=new RequestException("String_Node_Str",this.getRequest());
        try {
          this.result.setException(ex);
        }
 catch (        Exception t) {
        }
      }
    }
 else {
      this.requestResult.get();
    }
  }
 catch (  Exception ex) {
    Exceptions.maybeInterrupted(ex);
    Logs.extreme().error(ex,ex);
    this.result.setException(ex);
    throw Exceptions.toUndeclared(ex);
  }
  return this;
}
Program: 14815
Project: 14815
Buggy source:
@Override public void initialize(Q request) throws Exception {
  if (Logs.isExtrrreeeme()) {
    Logs.exhaust().debug(cb.getClass().getCanonicalName() + "String_Node_Str" + request);
  }
  try {
    cb.initialize(request);
  }
 catch (  Exception ex) {
    LOG.error(ex,ex);
    AsyncRequest.this.result.setException(ex);
    AsyncRequest.this.callbackSequence.fireException(ex);
  }
}

Fixed version (ground truth):
@Override public void initialize(Q request) throws Exception {
  if (Logs.isExtrrreeeme()) {
    Logs.exhaust().debug(cb.getClass().getCanonicalName() + "String_Node_Str" + request);
  }
  try {
    cb.initialize(request);
  }
 catch (  Exception ex) {
    Logs.extreme().error(ex,ex);
    AsyncRequest.this.result.setException(ex);
    AsyncRequest.this.callbackSequence.fireException(ex);
  }
}
Program: 14816
Project: 14816
Buggy source:
@Override public void fireException(Throwable t){
  try {
    cb.fireException(t);
    AsyncRequest.this.result.setException(t);
  }
 catch (  Exception ex) {
    AsyncRequest.this.result.setException(t);
    LOG.error(ex,ex);
  }
  try {
    AsyncRequest.this.callbackSequence.fireException(t);
  }
 catch (  Exception ex) {
    LOG.error(ex,ex);
  }
}

Fixed version (ground truth):
@Override public void fireException(Throwable t){
  try {
    cb.fireException(t);
    AsyncRequest.this.result.setException(t);
  }
 catch (  Exception ex) {
    AsyncRequest.this.result.setException(t);
    Logs.extreme().error(ex,ex);
  }
  try {
    AsyncRequest.this.callbackSequence.fireException(t);
  }
 catch (  Exception ex) {
    Logs.extreme().error(ex,ex);
  }
}
Program: 14818
Project: 14818
Buggy source:
/** 
 * Add a callback which is to be invoked if the operation succeeds.
 * @param c - callback to invoke
 * @return <tt>this</tt>
 */
@SuppressWarnings("String_Node_Str") public CallbackListenerSequence<R> addSuccessCallback(Callback.Success<R> c){
  EventRecord.caller(CallbackListenerSequence.class,EventType.CALLBACK,Callback.Success.class.getSimpleName(),c.getClass()).exhaust();
  this.successCallbacks.add(c);
  return this;
}

Fixed version (ground truth):
/** 
 * Add a callback which is to be invoked if the operation succeeds.
 * @param c - callback to invoke
 * @return <tt>this</tt>
 */
@SuppressWarnings("String_Node_Str") public CallbackListenerSequence<R> addSuccessCallback(Callback.Success<R> c){
  EventRecord.caller(CallbackListenerSequence.class,EventType.CALLBACK,Callback.Success.class.getSimpleName(),c.getClass()).extreme();
  this.successCallbacks.add(c);
  return this;
}
Program: 14819
Project: 14819
Buggy source:
/** 
 * Fire the response on all listeners.
 * @param response
 */
@Override public void fire(R response){
  EventRecord.here(CallbackListenerSequence.class,EventType.CALLBACK,"String_Node_Str" + response.getClass().getName() + "String_Node_Str").exhaust();
  for (  Callback<R> cb : this.successCallbacks) {
    try {
      EventRecord.here(this.getClass(),EventType.CALLBACK,"String_Node_Str" + cb.getClass(),"String_Node_Str" + response.getClass().getCanonicalName() + "String_Node_Str").exhaust();
      cb.fire(response);
    }
 catch (    Exception t) {
      this.LOG.error("String_Node_Str" + cb.getClass() + "String_Node_Str"+ t.getMessage()+ "String_Node_Str");
      this.LOG.error(t,t);
    }
  }
}

Fixed version (ground truth):
/** 
 * Fire the response on all listeners.
 * @param response
 */
@Override public void fire(R response){
  EventRecord.here(CallbackListenerSequence.class,EventType.CALLBACK,"String_Node_Str" + response.getClass().getName() + "String_Node_Str").extreme();
  for (  Callback<R> cb : this.successCallbacks) {
    try {
      EventRecord.here(this.getClass(),EventType.CALLBACK,"String_Node_Str" + cb.getClass(),"String_Node_Str" + response.getClass().getCanonicalName() + "String_Node_Str").extreme();
      cb.fire(response);
    }
 catch (    Exception t) {
      this.LOG.error("String_Node_Str" + cb.getClass() + "String_Node_Str"+ t.getMessage()+ "String_Node_Str");
      this.LOG.error(t,t);
    }
  }
}
Program: 14820
Project: 14820
Buggy source:
/** 
 * Add a callback which is to be invoked if the operation fails.
 * @param c - callback to invoke
 * @return <tt>this</tt>
 */
public CallbackListenerSequence<R> addFailureCallback(Callback.Failure c){
  EventRecord.caller(CallbackListenerSequence.class,EventType.CALLBACK,Callback.Failure.class.getSimpleName(),c.getClass()).exhaust();
  this.failureCallbacks.add(c);
  return this;
}

Fixed version (ground truth):
/** 
 * Add a callback which is to be invoked if the operation fails.
 * @param c - callback to invoke
 * @return <tt>this</tt>
 */
public CallbackListenerSequence<R> addFailureCallback(Callback.Failure c){
  EventRecord.caller(CallbackListenerSequence.class,EventType.CALLBACK,Callback.Failure.class.getSimpleName(),c.getClass()).extreme();
  this.failureCallbacks.add(c);
  return this;
}
Program: 14821
Project: 14821
Buggy source:
/** 
 * Trigger the failure case.
 * @param t
 */
@Override public void fireException(Throwable t){
  EventRecord.here(CallbackListenerSequence.class,EventType.CALLBACK,"String_Node_Str" + t.getClass().getName() + "String_Node_Str").debug();
  for (  Callback.Checked<R> cb : this.failureCallbacks) {
    try {
      EventRecord.here(this.getClass(),EventType.CALLBACK,"String_Node_Str" + cb.getClass(),"String_Node_Str" + t.getClass().getCanonicalName() + "String_Node_Str").debug();
      cb.fireException(t);
    }
 catch (    Exception t2) {
      this.LOG.error("String_Node_Str" + cb.getClass() + "String_Node_Str"+ t.getMessage()+ "String_Node_Str");
      this.LOG.error(t2,t2);
    }
  }
}

Fixed version (ground truth):
/** 
 * Trigger the failure case.
 * @param t
 */
@Override public void fireException(Throwable t){
  EventRecord.here(CallbackListenerSequence.class,EventType.CALLBACK,"String_Node_Str" + t.getClass().getName() + "String_Node_Str").extreme();
  for (  Callback.Checked<R> cb : this.failureCallbacks) {
    try {
      EventRecord.here(this.getClass(),EventType.CALLBACK,"String_Node_Str" + cb.getClass(),"String_Node_Str" + t.getClass().getCanonicalName() + "String_Node_Str").extreme();
      cb.fireException(t);
    }
 catch (    Exception t2) {
      this.LOG.error("String_Node_Str" + cb.getClass() + "String_Node_Str"+ t.getMessage()+ "String_Node_Str");
      this.LOG.error(t2,t2);
    }
  }
}
Program: 14822
Project: 14822
Buggy source:
/** 
 * Add a callback which is to be invoked when the operation completes, regardless of the outcome.
 * @param c - callback to invoke
 * @return <tt>this</tt>
 */
public CallbackListenerSequence<R> addCallback(Callback.Checked c){
  EventRecord.caller(CallbackListenerSequence.class,EventType.CALLBACK,Callback.Checked.class.getSimpleName(),c.getClass()).exhaust();
  this.successCallbacks.add(c);
  this.failureCallbacks.add(c);
  return this;
}

Fixed version (ground truth):
/** 
 * Add a callback which is to be invoked when the operation completes, regardless of the outcome.
 * @param c - callback to invoke
 * @return <tt>this</tt>
 */
public CallbackListenerSequence<R> addCallback(Callback.Checked c){
  EventRecord.caller(CallbackListenerSequence.class,EventType.CALLBACK,Callback.Checked.class.getSimpleName(),c.getClass()).extreme();
  this.successCallbacks.add(c);
  this.failureCallbacks.add(c);
  return this;
}
Program: 14823
Project: 14823
Buggy source:
public static RunInstancesResponseType runInstances(RunInstancesType request) throws MetadataException, AuthException {
  Allocation allocInfo=Allocations.begin(request);
  try {
    Predicates.and(VerifyMetadata.get(),AdmissionControl.get()).apply(allocInfo);
  }
 catch (  Exception ex1) {
    LOG.trace(ex1,ex1);
  }
  RunInstancesResponseType reply=allocInfo.getRequest().getReply();
  List<String> networkNames=Lists.transform(allocInfo.getNetworkGroups(),new Function<NetworkGroup,String>(){
    @Override public String apply(    NetworkGroup arg0){
      return arg0.getDisplayName();
    }
  }
);
  ReservationInfoType reservation=new ReservationInfoType(allocInfo.getReservationId(),allocInfo.getOwnerFullName().getAccountNumber(),Lists.newArrayList(networkNames));
  EntityTransaction db=Entities.get(VmInstance.class);
  try {
    for (    ResourceToken allocToken : allocInfo.getAllocationTokens()) {
      VmInstance entity=Entities.merge(allocToken.getVmInstance());
      reservation.getInstancesSet().add(VmInstances.transform(entity));
    }
    db.commit();
    ClusterAllocator.get().apply(allocInfo);
  }
 catch (  Exception ex) {
    Logs.exhaust().error(ex,ex);
    db.rollback();
    throw Exceptions.toUndeclared(ex);
  }
  reply.setRsvInfo(reservation);
  return reply;
}

Fixed version (ground truth):
public static RunInstancesResponseType runInstances(RunInstancesType request) throws MetadataException, AuthException {
  Allocation allocInfo=Allocations.begin(request);
  try {
    Predicates.and(VerifyMetadata.get(),AdmissionControl.get()).apply(allocInfo);
  }
 catch (  Exception ex1) {
    LOG.trace(ex1,ex1);
  }
  RunInstancesResponseType reply=allocInfo.getRequest().getReply();
  List<String> networkNames=Lists.transform(allocInfo.getNetworkGroups(),new Function<NetworkGroup,String>(){
    @Override public String apply(    NetworkGroup arg0){
      return arg0.getDisplayName();
    }
  }
);
  ReservationInfoType reservation=new ReservationInfoType(allocInfo.getReservationId(),allocInfo.getOwnerFullName().getAccountNumber(),Lists.newArrayList(networkNames));
  EntityTransaction db=Entities.get(VmInstance.class);
  try {
    for (    ResourceToken allocToken : allocInfo.getAllocationTokens()) {
      VmInstance entity=Entities.merge(allocToken.getVmInstance());
      reservation.getInstancesSet().add(VmInstances.transform(entity));
    }
    db.commit();
  }
 catch (  Exception ex) {
    Logs.exhaust().error(ex,ex);
    db.rollback();
    allocInfo.abort();
    throw Exceptions.toUndeclared(ex);
  }
  ClusterAllocator.get().apply(allocInfo);
  reply.setRsvInfo(reservation);
  return reply;
}
Program: 14824
Project: 14824
Buggy source:
@PreRemove private void preRemove(){
  if (this.extantNetwork != null) {
    this.extantNetwork.teardown();
    this.extantNetwork=null;
  }
}

Fixed version (ground truth):
@PreRemove private void preRemove(){
  if (this.extantNetwork != null && this.extantNetwork.teardown()) {
    Entities.delete(this.extantNetwork);
    this.extantNetwork=null;
  }
}
Program: 14825
Project: 14825
Buggy source:
/** 
 * {@inheritDoc ResourceAlllocation#reclaim()}
 * @see Reference#reclaim(com.eucalyptus.util.HasNaturalId)
 * @param referer
 * @return
 * @throws ResourceAllocationException
 */
@Override public final T reclaim(final R referer) throws ResourceAllocationException {
  final T ret=PersistentReference.this.doSetReferer(referer,Reference.State.FREE,Reference.State.EXTANT);
  return ret;
}

Fixed version (ground truth):
/** 
 * {@inheritDoc ResourceAlllocation#reclaim()}
 * @see Reference#reclaim(com.eucalyptus.util.HasNaturalId)
 * @param referer
 * @return
 * @throws ResourceAllocationException
 */
@Override public final T reclaim(final R referer) throws ResourceAllocationException {
  final T ret=PersistentReference.this.doSetReferer(referer,null,Reference.State.EXTANT);
  return ret;
}
Program: 14826
Project: 14826
Buggy source:
public PrivateNetworkIndex reclaimNetworkIndex(final Long idx) throws TransactionException {
  if (!NetworkGroups.networkingConfiguration().hasNetworking()) {
    try {
      return PrivateNetworkIndex.bogus().allocate();
    }
 catch (    final ResourceAllocationException ex) {
      throw new RuntimeException("String_Node_Str");
    }
  }
 else   if (!Entities.isPersistent(this)) {
    throw new TransientEntityException(this.toString());
  }
 else {
    final EntityTransaction db=Entities.get(PrivateNetworkIndex.class);
    try {
      try {
        final PrivateNetworkIndex netIdx=Entities.uniqueResult(PrivateNetworkIndex.named(this,idx));
        if (Reference.State.FREE.equals(netIdx.getState())) {
          final PrivateNetworkIndex ref=netIdx.allocate();
          db.commit();
          return ref;
        }
 else {
          try {
            netIdx.teardown();
          }
 catch (          final Exception ex) {
            LOG.error(ex,ex);
          }
          final PrivateNetworkIndex ref=Entities.persist(PrivateNetworkIndex.create(this,idx)).allocate();
          db.commit();
          return ref;
        }
      }
 catch (      final Exception ex) {
        final PrivateNetworkIndex ref=Entities.persist(PrivateNetworkIndex.create(this,idx)).allocate();
        db.commit();
        return ref;
      }
    }
 catch (    final Exception ex) {
      Logs.exhaust().error(ex,ex);
      db.rollback();
      throw new TransactionExecutionException("String_Node_Str" + this.displayName,ex);
    }
  }
}

Fixed version (ground truth):
public PrivateNetworkIndex reclaimNetworkIndex(final Long idx) throws Exception {
  if (!NetworkGroups.networkingConfiguration().hasNetworking()) {
    try {
      return PrivateNetworkIndex.bogus().allocate();
    }
 catch (    final ResourceAllocationException ex) {
      throw new RuntimeException("String_Node_Str");
    }
  }
 else   if (!Entities.isPersistent(this)) {
    throw new TransientEntityException(this.toString());
  }
 else {
    try {
      return Entities.uniqueResult(PrivateNetworkIndex.named(this,idx));
    }
 catch (    final Exception ex) {
      return Entities.persist(PrivateNetworkIndex.create(this,idx)).allocate();
    }
  }
}
Program: 14827
Project: 14827
Buggy source:
public static void handleReportedState(final VmInfo runVm){
  final VmState runVmState=VmState.Mapper.get(runVm.getStateName());
  EntityTransaction db=Entities.get(VmInstance.class);
  try {
    try {
      VmInstance vm=VmInstances.lookup(runVm.getInstanceId());
      if (VmState.SHUTTING_DOWN.equals(runVmState)) {
        VmStateCallback.handleReportedTeardown(vm,runVm);
      }
 else       if (VmStateSet.RUN.apply(vm)) {
        vm.doUpdate().apply(runVm);
      }
 else       if (!VmStateSet.RUN.apply(vm) && VmStateSet.RUN.contains(runVmState) && vm.lastUpdateMillis() > (VmInstances.VOLATILE_STATE_TIMEOUT_SEC * 1000l)) {
        vm.doUpdate().apply(runVm);
      }
      db.commit();
    }
 catch (    Exception ex) {
      LOG.trace(ex,ex);
      db.rollback();
      throw ex;
    }
  }
 catch (  TerminatedInstanceException ex1) {
    LOG.trace("String_Node_Str" + runVm.getInstanceId());
  }
catch (  NoSuchElementException ex1) {
    if (VmStateSet.RUN.contains(runVmState)) {
      VmStateCallback.handleRestore(runVm);
    }
  }
catch (  Exception ex1) {
    LOG.trace(ex1,ex1);
  }
}

Fixed version (ground truth):
public static void handleReportedState(final VmInfo runVm){
  final VmState runVmState=VmState.Mapper.get(runVm.getStateName());
  try {
    EntityTransaction db=Entities.get(VmInstance.class);
    try {
      VmInstance vm=VmInstances.lookup(runVm.getInstanceId());
      if (VmState.SHUTTING_DOWN.equals(runVmState)) {
        VmStateCallback.handleReportedTeardown(vm,runVm);
      }
 else       if (VmStateSet.RUN.apply(vm)) {
        vm.doUpdate().apply(runVm);
      }
 else       if (!VmStateSet.RUN.apply(vm) && VmStateSet.RUN.contains(runVmState) && vm.lastUpdateMillis() > (VmInstances.VOLATILE_STATE_TIMEOUT_SEC * 1000l)) {
        vm.doUpdate().apply(runVm);
      }
      db.commit();
    }
 catch (    Exception ex) {
      LOG.trace(ex,ex);
      db.rollback();
      throw ex;
    }
  }
 catch (  TerminatedInstanceException ex1) {
    LOG.trace("String_Node_Str" + runVm.getInstanceId());
  }
catch (  NoSuchElementException ex1) {
    if (VmStateSet.RUN.contains(runVmState)) {
      VmStateCallback.handleRestore(runVm);
    }
  }
catch (  Exception ex1) {
    LOG.trace(ex1,ex1);
  }
}
Program: 14828
Project: 14828
Buggy source:
private static BootableSet bootsetWithKernel(BootableSet bootSet) throws MetadataException {
  String kernelId=determineKernelId(bootSet);
  LOG.debug("String_Node_Str" + kernelId + "String_Node_Str"+ bootSet.toString());
  try {
    KernelImageInfo kernel=RestrictedTypes.doPrivileged(kernelId,LookupKernel.INSTANCE,true);
    return new NoRamdiskBootableSet(bootSet.getMachine(),kernel);
  }
 catch (  Exception ex) {
    throw new NoSuchMetadataException("String_Node_Str" + kernelId + "String_Node_Str"+ ex.getMessage(),ex);
  }
}

Fixed version (ground truth):
private static BootableSet bootsetWithKernel(BootableSet bootSet) throws MetadataException {
  String kernelId=determineKernelId(bootSet);
  LOG.debug("String_Node_Str" + kernelId + "String_Node_Str"+ bootSet.toString());
  try {
    KernelImageInfo kernel=RestrictedTypes.doPrivilegedWithoutOwner(kernelId,LookupKernel.INSTANCE);
    return new NoRamdiskBootableSet(bootSet.getMachine(),kernel);
  }
 catch (  Exception ex) {
    throw new NoSuchMetadataException("String_Node_Str" + kernelId + "String_Node_Str"+ ex.getMessage(),ex);
  }
}
Program: 14829
Project: 14829
Buggy source:
public static <T extends ImageInfo>T resolveDiskImage(String imageId,Function<String,T> resolver) throws IllegalMetadataAccessException {
  T img=resolver.apply(imageId);
  Predicate<T> filter=Predicates.and(Images.FilterPermissions.INSTANCE,RestrictedTypes.filterPrivileged(true));
  if (filter.apply(img)) {
    return img;
  }
 else {
    throw new IllegalMetadataAccessException(imageId + "String_Node_Str");
  }
}

Fixed version (ground truth):
public static <T extends ImageInfo>T resolveDiskImage(String imageId,Function<String,T> resolver) throws IllegalMetadataAccessException {
  T img=resolver.apply(imageId);
  Predicate<T> filter=Predicates.and(Images.FilterPermissions.INSTANCE,RestrictedTypes.filterPrivilegedWithoutOwner());
  if (filter.apply(img)) {
    return img;
  }
 else {
    throw new IllegalMetadataAccessException(imageId + "String_Node_Str");
  }
}
Program: 14830
Project: 14830
Buggy source:
private static BootableSet bootsetWithRamdisk(BootableSet bootSet) throws MetadataException {
  String ramdiskId=determineRamdiskId(bootSet);
  LOG.debug("String_Node_Str" + ramdiskId + "String_Node_Str"+ bootSet.toString());
  if (ramdiskId == null) {
    return bootSet;
  }
 else {
    try {
      RamdiskImageInfo ramdisk=RestrictedTypes.doPrivileged(ramdiskId,LookupRamdisk.INSTANCE,true);
      return new TrifectaBootableSet(bootSet.getMachine(),bootSet.getKernel(),ramdisk);
    }
 catch (    Exception ex) {
      throw new NoSuchMetadataException("String_Node_Str" + ramdiskId + "String_Node_Str"+ ex.getMessage(),ex);
    }
  }
}

Fixed version (ground truth):
private static BootableSet bootsetWithRamdisk(BootableSet bootSet) throws MetadataException {
  String ramdiskId=determineRamdiskId(bootSet);
  LOG.debug("String_Node_Str" + ramdiskId + "String_Node_Str"+ bootSet.toString());
  if (ramdiskId == null) {
    return bootSet;
  }
 else {
    try {
      RamdiskImageInfo ramdisk=RestrictedTypes.doPrivilegedWithoutOwner(ramdiskId,LookupRamdisk.INSTANCE);
      return new TrifectaBootableSet(bootSet.getMachine(),bootSet.getKernel(),ramdisk);
    }
 catch (    Exception ex) {
      throw new NoSuchMetadataException("String_Node_Str" + ramdiskId + "String_Node_Str"+ ex.getMessage(),ex);
    }
  }
}