Java Transaction类代码示例

import org.skife.jdbi.v2.sqlobject.Transaction; //导入依赖的package包/类
@Transaction
@Override
public Response toolsIdVersionsPost(String id, ToolVersion body, SecurityContext securityContext) throws NotFoundException {
    // refresh the release on github
    //gitHubBuilder.createBranchAndRelease(, , body.getName());
    String[] split = id.split("/");
    LOG.info("Creating branch...");
    String organization = split[0];
    String repo = split[1];
    String version = body.getName();
    gitHubBuilder.createBranchAndRelease(organization, repo, version);
    try {
        int insert = toolVersionDAO.insert(id, version);
        if (insert != 1) {
            LOG.info("Tool version already exists in database");
            return Response.notModified().build();
        }
    } catch (UnableToExecuteStatementException e) {
        LOG.info("Tool version already exists in database");
    }
    ToolVersion byId = toolVersionDAO.findByToolVersion(id, version);
    if (byId == null) {
        return Response.notModified().build();
    }
    return Response.ok().entity(byId).build();
}
 

import org.skife.jdbi.v2.sqlobject.Transaction; //导入依赖的package包/类
@Transaction
@Override
public Response toolsIdVersionsVersionIdTypeDescriptorPost(String type, String id, String versionId, ToolDescriptor body,
        SecurityContext securityContext) throws NotFoundException {
    String[] split = id.split("/");
    String organization = split[0];
    String repo = split[1];
    String path = body.getUrl();
    String url = generateUrl(id, versionId, body.getUrl());
    ToolDescriptor byId = toolDescriptorDAO.findByPath(id, versionId, path);
    if (byId == null) {
        try {
            toolDescriptorDAO.insert(body.getDescriptor(), id, versionId, path);
        } catch (UnableToExecuteStatementException e) {
            LOG.debug("Descriptor already exists in database");

        }
    }
    gitHubBuilder.stashFile(organization, repo, body.getUrl(), body.getDescriptor(), versionId);
    // TODO: improve this, this looks slow and awkward
    body.setUrl(url);
    toolDescriptorDAO.update(body, id, versionId, path);
    byId = toolDescriptorDAO.findByPath(id, versionId, path);
    return Response.ok().entity(byId).build();
}
 

import org.skife.jdbi.v2.sqlobject.Transaction; //导入依赖的package包/类
@Transaction
@Override
public Response toolsPost(Tool body, SecurityContext securityContext) throws NotFoundException {
    // try creating a repo on github for this, this should probably be made into a transaction
    if (!gitHubBuilder.repoExists(body.getOrganization(), body.getToolname())) {
        LOG.info("Repo does not exist");
        boolean repo = gitHubBuilder.createRepo(body.getOrganization(), body.getToolname());
        if (!repo) {
            return Response.notModified("Could not create github repo").build();
        }
    }
    try {
        toolDAO.insert(body.getId());
    } catch (UnableToExecuteStatementException e) {
        LOG.info("Tool already exists in database");
    }
    String gitUrl = gitHubBuilder.getGitUrl(body.getOrganization(), body.getToolname());
    body.setUrl(gitUrl);
    toolDAO.update(body);
    Tool byId = toolDAO.findById(body.getId());
    if (byId != null) {
        return Response.ok().entity(byId).build();
    }
    return Response.notModified().build();
}
 

import org.skife.jdbi.v2.sqlobject.Transaction; //导入依赖的package包/类
@Transaction
@Override
public Response toolsIdPut(String id, Tool body, SecurityContext securityContext) throws NotFoundException {
    // ensure that id matches
    if (!Objects.equals(id, body.getId())) {
        return Response.notModified().build();
    }
    int update = toolDAO.update(body);
    if (update != 1) {
        return Response.notModified().build();
    }
    return Response.ok().entity(toolDAO.findById(id)).build();
}
 

import org.skife.jdbi.v2.sqlobject.Transaction; //导入依赖的package包/类
@Transaction
@Override
public Response toolsIdVersionsVersionIdDockerfileGet(String id, String versionId, SecurityContext securityContext)
        throws NotFoundException {
    ToolDockerfile byId = toolDockerfileDAO.findById(id, versionId);
    return Response.ok().entity(byId).build();
}
 

import org.skife.jdbi.v2.sqlobject.Transaction; //导入依赖的package包/类
@Transaction
@Override
public Response toolsIdVersionsVersionIdDockerfilePost(String id, String versionId, ToolDockerfile dockerfile,
        SecurityContext securityContext) throws NotFoundException {
    String[] split = id.split("/");
    String organization = split[0];
    String repo = split[1];
    gitHubBuilder.stashFile(organization, repo, dockerfile.getUrl(), dockerfile.getDockerfile(), versionId);
    gitHubBuilder.createBranchAndRelease(organization, repo, versionId);
    if (!quayIoBuilder.repoExists(organization, repo)) {
        quayIoBuilder.createRepo(organization, repo, repo);
        LOG.info("Created quay.io repository.");
    }
    quayIoBuilder.triggerBuild(organization, organization, repo, repo, versionId, true);
    String url = generateUrl(id, versionId, dockerfile.getUrl());
    dockerfile.setUrl(url);
    ToolDockerfile findById = toolDockerfileDAO.findById(id, versionId);
    if (findById == null) {
        try {
            toolDockerfileDAO.insert(id, versionId, dockerfile.getDockerfile());
            toolDockerfileDAO.update(dockerfile, id, versionId);
        } catch (UnableToExecuteStatementException e) {
            LOG.info("Dockerfile already exists in database");
        }
    }
    toolDockerfileDAO.update(dockerfile, id, versionId);
    ToolDockerfile created = toolDockerfileDAO.findById(id, versionId);

    if (created != null) {
        created.setUrl(quayIoBuilder.getQuayUrl(organization, repo));
        return Response.ok().entity(created).build();
    }
    return Response.serverError().build();
}
 

import org.skife.jdbi.v2.sqlobject.Transaction; //导入依赖的package包/类
@Transaction
@Override
public Response toolsIdVersionsVersionIdPut(String id, String versionId, ToolVersion body, SecurityContext securityContext)
        throws NotFoundException {
    // ensure that id matches
    if (!Objects.equals(versionId, body.getId())) {
        return Response.notModified().build();
    }
    int update = toolVersionDAO.update(body);
    if (update != 1) {
        return Response.notModified().build();
    }
    return Response.ok().entity(toolVersionDAO.findByToolVersion(id, versionId)).build();
}
 

import org.skife.jdbi.v2.sqlobject.Transaction; //导入依赖的package包/类
@Transaction
@Override
public Response toolsIdVersionsVersionIdTypeDescriptorRelativePathPost(String type, String id, String versionId, String relativePath,
        ToolDescriptor body, SecurityContext securityContext) throws NotFoundException {
    // hook up to github

    return Response.ok().entity(new ApiResponseMessage(ApiResponseMessage.OK, "magic!")).build();
}
 

import org.skife.jdbi.v2.sqlobject.Transaction; //导入依赖的package包/类
@Transaction
@Override
public Response toolsIdVersionsVersionIdTypeTestsPut(String type, String id, String versionId, List<ToolTests> body,
        SecurityContext securityContext) throws NotFoundException {
    // do some magic!
    return Response.ok().entity(new ApiResponseMessage(ApiResponseMessage.OK, "magic!")).build();
}
 

import org.skife.jdbi.v2.sqlobject.Transaction; //导入依赖的package包/类
@Transaction
public void createUser(final DBUser user) {
    insertUser(user);
    for (final Roles role : user.getRoles()) {
        insertUserRole(UUID.randomUUID(), user, role);
    }
}
 

import org.skife.jdbi.v2.sqlobject.Transaction; //导入依赖的package包/类
@Transaction
public int update(JdbcSource source, DataSourceDAO dao, Encrypt encrypt) {
  try {
    source.setUrl(encrypt.convertToDatabaseColumn(source.getUrl()));
    source.setUsername(encrypt.convertToDatabaseColumn(source.getUsername()));
    source.setPassword(encrypt.convertToDatabaseColumn(source.getPassword()));
  } catch (SQLException e) {
    throw new RuntimeException(e);
  }
  updateJdbc(source);
  return dao.update(source);
}
 

import org.skife.jdbi.v2.sqlobject.Transaction; //导入依赖的package包/类
@Transaction
public int update(QuboleDbSource db, DataSourceDAO dao, Encrypt encrypt) {
  try {
    db.setUrl(encrypt.convertToDatabaseColumn(db.getUrl()));
    db.setAuthToken(encrypt.convertToDatabaseColumn(db.getAuthToken()));
  } catch (SQLException e) {
    throw new RuntimeException(e);
  }
  updateQubole(db);
  return dao.update(db);
}
 

import org.skife.jdbi.v2.sqlobject.Transaction; //导入依赖的package包/类
@Transaction
public int insertQuboleDB(String name, String type, String url, long dsSetId,
    String dataSourcetype, QuboleDbSourceDAO quboleDao, int dbTapId, String authToken,
    Encrypt encrypt) {
  try {
    url = encrypt.convertToDatabaseColumn(url);
    authToken = encrypt.convertToDatabaseColumn(authToken);
  } catch (SQLException e) {
    throw new RuntimeException(e);
  }
  int id = insert(name, type, url, dsSetId, dataSourcetype);
  quboleDao.insert(id, dbTapId, authToken);
  return id;
}
 

import org.skife.jdbi.v2.sqlobject.Transaction; //导入依赖的package包/类
@Transaction
public void addNewRuleSet(CdxAccessControl ruleset) throws JsonProcessingException {
  long newRulesetId = newRuleset();
  ruleset.setRulesSetId(newRulesetId);
  for (CdxRule rule : ruleset.getRules().values()) {
    String json = jsonMapper.writeValueAsString(rule);
    writeRule(newRulesetId, rule.getId(), json);
  }
}
 

import org.skife.jdbi.v2.sqlobject.Transaction; //导入依赖的package包/类
@Transaction
public void finishNightyRun(long id, CdxAccessControl newRules, CdxAccessControl currentRules) {
	Date activationTime = new Date();
	finishNightyRunForId(id, activationTime);
	if(newRules != null){
		// we have a new rule set so retire the current and make the new active
  	if(currentRules != null && currentRules.getRulesSetId() > 0){
  		retireCurrentRules(currentRules.getRulesSetId(), activationTime);
  	}
  	if(newRules != null && newRules.getRulesSetId() > 0){
  		activateNewRules(newRules.getRulesSetId(), activationTime);
  	}
	}
}