o Dropping quartz, using straight executor service.

10 files changed, 259 insertions, 202 deletions

diff --git a/src/main/java/io/trygvis/CreateArticleCallable.java b/src/main/java/io/trygvis/CreateArticleCallable.java
index e727b46..85734fc 100755
--- a/src/main/java/io/trygvis/CreateArticleCallable.java
+++ b/src/main/java/io/trygvis/CreateArticleCallable.java
@@ -6,21 +6,28 @@ import org.slf4j.*;
 import org.springframework.stereotype.*;
 import org.springframework.transaction.annotation.*;
 
-import java.util.*;
 import javax.persistence.*;
+import java.util.*;
 
 import static org.springframework.transaction.annotation.Propagation.*;
 
-@Component
+@Component("createArticle")
+@Transactional(propagation = MANDATORY)
 public class CreateArticleCallable implements AsyncService.AsyncCallable {
     private final Logger log = LoggerFactory.getLogger(getClass());
 
     @PersistenceContext
     private EntityManager entityManager;
 
-//    @Transactional(propagation = REQUIRES_NEW)
+    private Random random = new Random();
+
     public void run() throws Exception {
         log.info("CreateArticeJob.run: BEGIN");
+
+        if (random.nextBoolean()) {
+            throw new RuntimeException("failing create article");
+        }
+
         Date now = new Date();
 
         log.info("now = {}", now);
diff --git a/src/main/java/io/trygvis/Main.java b/src/main/java/io/trygvis/Main.java
index aafb728..448c3e4 100755
--- a/src/main/java/io/trygvis/Main.java
+++ b/src/main/java/io/trygvis/Main.java
@@ -7,12 +7,12 @@ import org.slf4j.bridge.*;
 import org.springframework.beans.factory.annotation.*;

 import org.springframework.context.support.*;

 import org.springframework.stereotype.*;

-import org.springframework.transaction.annotation.*;

+

+import java.util.*;

 

 import static java.lang.System.*;

 

 @Component

-@Transactional

 public class Main {

     private static final Logger log = LoggerFactory.getLogger(Main.class);

 

@@ -23,7 +23,7 @@ public class Main {
         setProperty("database.url", getProperty("jdbc.url", "jdbc:postgresql://localhost/" + username));

         setProperty("database.username", username);

         setProperty("database.password", username);

-        setProperty("hibernate.showSql", "true");

+//        setProperty("hibernate.showSql", "true");

         setProperty("hibernate.hbm2ddl.auto", "create"); // create

         setProperty("hibernate.dialect", PostgreSQL82Dialect.class.getName());

 

@@ -50,19 +50,26 @@ public class Main {
     private AsyncService<AsyncService.QueueRef, AsyncService.ExecutionRef> asyncService;

 

     @Autowired

-    private CreateArticleCallable createArticleCallable;

+    @Qualifier("createArticle")

+    private AsyncService.AsyncCallable createArticleCallable;

 

     @Autowired

-    private UpdateArticeCallable updateArticeCallable;

+    @Qualifier("createArticle")

+    private AsyncService.AsyncCallable/*UpdateArticleCallable*/ updateArticleCallable;

 

     public void run() throws Exception {

         log.info("Main.run");

 

-        asyncService.registerQueue("create-queue", 1, createArticleCallable);

+        JpaAsyncService.JpaQueueRef queueRef = asyncService.registerQueue("create-queue", 10, createArticleCallable);

+        log.info("queue registered: ref = {}", queueRef);

 //        asyncService.registerQueue("update-queue", 1, updateArticeCallable);

 

         AsyncService.QueueRef queue = asyncService.getQueue("create-queue");

 

-        AsyncService.ExecutionRef executionRef = asyncService.schedule(queue);

+        List<AsyncService.ExecutionRef> refs = new ArrayList<>();

+

+        for (int i = 0; i < 10; i++) {

+            refs.add(asyncService.schedule(queue));

+        }

     }

 }

diff --git a/src/main/java/io/trygvis/UpdateArticeCallable.java b/src/main/java/io/trygvis/UpdateArticleCallable.java
index d022655..7ed8b63 100755
--- a/src/main/java/io/trygvis/UpdateArticeCallable.java
+++ b/src/main/java/io/trygvis/UpdateArticleCallable.java
@@ -12,7 +12,8 @@ import javax.persistence.*;
 import static org.springframework.transaction.annotation.Propagation.*;
 
 @Component
-public class UpdateArticeCallable implements AsyncService.AsyncCallable {
+public class UpdateArticleCallable
+    implements AsyncService.AsyncCallable {
     private final Logger log = LoggerFactory.getLogger(getClass());
 
     private final Random r = new Random();
diff --git a/src/main/java/io/trygvis/data/TaskRepository.java b/src/main/java/io/trygvis/data/TaskRepository.java
index 0b65199..e24d520 100755
--- a/src/main/java/io/trygvis/data/TaskRepository.java
+++ b/src/main/java/io/trygvis/data/TaskRepository.java
@@ -1,7 +1,11 @@
 package io.trygvis.data;

 

 import io.trygvis.model.*;

+import io.trygvis.model.Queue;

 import org.springframework.data.jpa.repository.*;

 

+import java.util.*;

+

 public interface TaskRepository extends JpaRepository<Task, Long> {

+    List<Task> findByQueueAndCompletedIsNull(Queue queue);

 }

diff --git a/src/main/java/io/trygvis/model/Queue.java b/src/main/java/io/trygvis/model/Queue.java
index 52c5c0f..aeec405 100755
--- a/src/main/java/io/trygvis/model/Queue.java
+++ b/src/main/java/io/trygvis/model/Queue.java
@@ -19,6 +19,10 @@ public class Queue {
 

     private long interval;

 

+    @SuppressWarnings("UnusedDeclaration")

+    private Queue() {

+    }

+

     public Queue(String name, long interval) {

         this.name = name;

         this.interval = interval;

@@ -43,4 +47,12 @@ public class Queue {
     public void setInterval(long interval) {

         this.interval = interval;

     }

+

+    public String toString() {

+        return "Queue{" +

+                "id=" + id +

+                ", name='" + name + '\'' +

+                ", interval=" + interval +

+                '}';

+    }

 }

diff --git a/src/main/java/io/trygvis/model/Task.java b/src/main/java/io/trygvis/model/Task.java
index fa44e26..e86b623 100755
--- a/src/main/java/io/trygvis/model/Task.java
+++ b/src/main/java/io/trygvis/model/Task.java
@@ -1,6 +1,8 @@
 package io.trygvis.model;

 

 import javax.persistence.*;

+import java.util.*;

+import java.util.regex.*;

 

 @Entity

 public class Task {

@@ -12,21 +14,81 @@ public class Task {
     @ManyToOne

     private Queue queue;

 

-    private Long long1;

+    private Date scheduled;

 

-    public Task(Queue queue) {

+    private Date lastRun;

+

+    private int runCount;

+

+    private Date completed;

+

+    private String arguments;

+

+    private static final Pattern pattern = Pattern.compile(" ");

+

+    @SuppressWarnings("UnusedDeclaration")

+    private Task() {

+    }

+

+    public Task(Queue queue, Date scheduled, String... arguments) {

         this.queue = queue;

+        this.scheduled = scheduled;

+

+        StringBuilder builder = new StringBuilder(arguments.length * 100);

+        for (String argument : arguments) {

+            if (pattern.matcher(argument).matches()) {

+                throw new RuntimeException("Bad argument: '" + argument + "'.");

+            }

+            builder.append(argument).append(' ');

+        }

+        this.arguments = builder.toString();

     }

 

     public Integer getId() {

         return id;

     }

 

-    public Long getLong1() {

-        return long1;

+    public String[] getArguments() {

+        return arguments.split(" ");

+    }

+

+    public Date getScheduled() {

+        return scheduled;

+    }

+

+    public Date getLastRun() {

+        return lastRun;

+    }

+

+    public int getRunCount() {

+        return runCount;

+    }

+

+    public Date getCompleted() {

+        return completed;

+    }

+

+    public void setCompleted(Date completed) {

+        this.completed = completed;

+    }

+

+    public void registerRun() {

+        lastRun = new Date();

+        runCount++;

+    }

+

+    public void registerComplete(Date completed) {

+        this.completed = completed;

     }

 

-    public void setLong1(Long long1) {

-        this.long1 = long1;

+    public String toString() {

+        return "Task{" +

+                "id=" + id +

+                ", queue=" + queue +

+                ", scheduled=" + scheduled +

+                ", lastRun=" + lastRun +

+                ", completed=" + completed +

+                ", arguments='" + arguments + '\'' +

+                '}';

     }

 }

diff --git a/src/main/java/io/trygvis/queue/AsyncService.java b/src/main/java/io/trygvis/queue/AsyncService.java
index de0a1af..f792f5e 100755
--- a/src/main/java/io/trygvis/queue/AsyncService.java
+++ b/src/main/java/io/trygvis/queue/AsyncService.java
@@ -4,11 +4,11 @@ import org.quartz.*;
 

 public interface AsyncService<QueueRef extends AsyncService.QueueRef, ExecutionRef extends AsyncService.ExecutionRef> {

 

-    void registerQueue(String name, int interval, AsyncCallable callable) throws SchedulerException;

+    JpaAsyncService.JpaQueueRef registerQueue(String name, int interval, AsyncCallable callable) throws SchedulerException;

 

     QueueRef getQueue(String name);

 

-    ExecutionRef schedule(QueueRef queue);

+    ExecutionRef schedule(QueueRef queue, String... args);

 

     interface QueueRef {

     }

diff --git a/src/main/java/io/trygvis/queue/JpaAsyncService.java b/src/main/java/io/trygvis/queue/JpaAsyncService.java
index e715c6d..95d5ef3 100755
--- a/src/main/java/io/trygvis/queue/JpaAsyncService.java
+++ b/src/main/java/io/trygvis/queue/JpaAsyncService.java
@@ -1,61 +1,36 @@
 package io.trygvis.queue;

 

-import io.trygvis.data.QueueRepository;

-import io.trygvis.data.TaskRepository;

+import io.trygvis.data.*;

 import io.trygvis.model.Queue;

-import org.quartz.Job;

-import org.quartz.JobDataMap;

-import org.quartz.JobExecutionContext;

-import org.quartz.JobExecutionException;

-import org.quartz.JobKey;

-import org.quartz.JobPersistenceException;

-import org.quartz.Scheduler;

-import org.quartz.SchedulerException;

-import org.quartz.SchedulerFactory;

-import org.quartz.SimpleScheduleBuilder;

-import org.quartz.SimpleTrigger;

-import org.quartz.TriggerBuilder;

-import org.quartz.impl.JobDetailImpl;

-import org.quartz.impl.StdSchedulerFactory;

-import org.quartz.impl.jdbcjobstore.*;

-import org.slf4j.Logger;

-import org.slf4j.LoggerFactory;

-import org.springframework.beans.BeansException;

-import org.springframework.beans.factory.annotation.Autowired;

-import org.springframework.context.ApplicationContext;

-import org.springframework.context.ApplicationContextAware;

-import org.springframework.jdbc.datasource.DataSourceUtils;

-import org.springframework.stereotype.Component;

-import org.springframework.transaction.PlatformTransactionManager;

-import org.springframework.transaction.annotation.Transactional;

-

-import javax.annotation.*;

-import javax.persistence.EntityManager;

-import javax.persistence.PersistenceContext;

-import javax.persistence.RollbackException;

-import javax.persistence.TypedQuery;

-import javax.sql.DataSource;

-import java.sql.Connection;

-import java.sql.SQLException;

+import io.trygvis.model.*;

+import org.quartz.*;

+import org.slf4j.*;

+import org.springframework.beans.factory.annotation.*;

+import org.springframework.stereotype.*;

+import org.springframework.transaction.*;

+import org.springframework.transaction.annotation.*;

+import org.springframework.transaction.support.*;

+

+import javax.persistence.*;

 import java.util.*;

+import java.util.concurrent.*;

 

-import static org.quartz.SimpleScheduleBuilder.simpleSchedule;

+import static java.util.concurrent.TimeUnit.*;

+import static org.springframework.transaction.support.TransactionSynchronizationManager.*;

 

 @SuppressWarnings("SpringJavaAutowiringInspection")

 @Component

-public class JpaAsyncService implements AsyncService<JpaAsyncService.JpaQueueRef, JpaAsyncService.JpaExecutionRef>,

-        ApplicationContextAware {

+public class JpaAsyncService implements AsyncService<JpaAsyncService.JpaQueueRef, JpaAsyncService.JpaExecutionRef>/*, ApplicationContextAware*/ {

 

     private final Logger log = LoggerFactory.getLogger(getClass());

 

+    private final ScheduledThreadPoolExecutor executor = new ScheduledThreadPoolExecutor(10, Executors.defaultThreadFactory());

+

     @PersistenceContext

     private EntityManager entityManager;

 

     @Autowired

-    private DataSource dataSource;

-

-    @Autowired

-    private PlatformTransactionManager transactionManager;

+    private TransactionTemplate transactionTemplate;

 

     @Autowired

     private QueueRepository queueRepository;

@@ -63,59 +38,17 @@ public class JpaAsyncService implements AsyncService<JpaAsyncService.JpaQueueRef
     @Autowired

     private TaskRepository taskRepository;

 

-    private Scheduler scheduler;

-

-    private static DataSource dataSourceStatic;

-

-    private static PlatformTransactionManager transactionManagerStatic;

-

-    private static class Context {

-        ApplicationContext applicationContext;

-        List<AsyncCallable> callables = new ArrayList<>();

-    }

-

-    private final Context context = new Context();

-

-    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {

-        this.context.applicationContext = applicationContext;

-    }

-

-    @PostConstruct

-    public void postConstruct() throws Exception {

-        transactionManagerStatic = transactionManager;

-        dataSourceStatic = dataSource;

-        log.info("afterPropertiesSet!!");

-        Properties quartzProperties = new Properties();

-        quartzProperties.setProperty(StdSchedulerFactory.PROP_JOB_STORE_CLASS, JobStoreTX.class.getName());

-        quartzProperties.setProperty(StdSchedulerFactory.PROP_SCHED_INSTANCE_NAME, "queue");

-        quartzProperties.setProperty(StdSchedulerFactory.PROP_SCHED_SKIP_UPDATE_CHECK, "true");

-        quartzProperties.setProperty(StdSchedulerFactory.PROP_SCHED_SKIP_UPDATE_CHECK, "true");

-//        quartzProperties.setProperty(StdSchedulerFactory.PROP_DATASOURCE_PREFIX, "wat");

-        quartzProperties.setProperty(StdSchedulerFactory.PROP_JOB_STORE_CLASS, JpaDataSourceJobStore.class.getName());

-        quartzProperties.setProperty(StdSchedulerFactory.PROP_JOB_STORE_LOCK_HANDLER_CLASS, SimpleSemaphore.class.getName());

-        quartzProperties.setProperty("org.quartz.threadPool.threadCount", "10");

-        quartzProperties.setProperty("org.quartz.jobStore.driverDelegateClass", PostgreSQLDelegate.class.getName());

-        quartzProperties.setProperty("org.quartz.scheduler.jmx.export", "true");

-        SchedulerFactory schedulerFactory = new StdSchedulerFactory(quartzProperties);

-

-        scheduler = schedulerFactory.getScheduler();

-        scheduler.getContext().put("context", context);

-        scheduler.start();

-    }

-

-    @PreDestroy

-    public void preDestroy() throws Exception {

-        scheduler.shutdown();

-    }

-

     @Transactional

-    public synchronized void registerQueue(String name, int interval, AsyncCallable callable) throws SchedulerException {

+    public synchronized JpaQueueRef registerQueue(String name, int interval, AsyncCallable callable) throws SchedulerException {

+        log.info("registerQueue: ENTER");

 

         Queue q = queueRepository.findByName(name);

 

+        log.info("q = {}", q);

+

         if (q == null) {

-            Queue queue = new Queue(name, interval);

-            queueRepository.save(queue);

+            q = new Queue(name, interval);

+            q = queueRepository.save(q);

         } else {

             boolean dirty = false;

             if (interval != q.getInterval()) {

@@ -124,133 +57,170 @@ public class JpaAsyncService implements AsyncService<JpaAsyncService.JpaQueueRef
             }

 

             if (dirty) {

-                queueRepository.save(q);

+                q = queueRepository.save(q);

             }

         }

 

-        context.callables.add(callable);

-        int index = context.callables.size() - 1;

+        log.info("q = {}", q);

+        entityManager.flush();

+//        entityManager.detach(q);

+        log.info("q = {}", q);

 

-        JobDetailImpl jobDetail = new JobDetailImpl();

-        JobKey jobKey = JobKey.jobKey("queue-" + name);

+        JpaQueueRef queueRef = new JpaQueueRef(q);

 

-        jobDetail.setKey(jobKey);

-        jobDetail.setJobClass(AsyncServiceJob.class);

-        jobDetail.setDurability(true);

-        jobDetail.getJobDataMap().put("index", Integer.toString(index));

-        scheduler.addJob(jobDetail, true);

+        log.info("registerQueue: LEAVE");

 

-        SimpleScheduleBuilder schedule = simpleSchedule().

-                repeatForever().

-                withIntervalInSeconds(interval);

-

-        SimpleTrigger trigger = TriggerBuilder.newTrigger().

-                withSchedule(schedule).

-                withIdentity(jobKey.getName()).

-                forJob(jobKey).

-                build();

-

-        if(scheduler.checkExists(trigger.getKey())) {

-            scheduler.unscheduleJob(trigger.getKey());

-        }

+        registerSynchronization(new MyTransactionSynchronization(callable, interval, queueRef));

 

-        scheduler.scheduleJob(trigger);

+        return queueRef;

     }

 

     @Transactional(readOnly = true)

     public JpaQueueRef getQueue(String name) {

-        TypedQuery<Queue> query = entityManager.createQuery("select q from io.trygvis.model.Queue q where name = ?1", Queue.class);

-        query.setParameter(1, name);

-        List<Queue> list = query.getResultList();

-        System.out.println("list.size() = " + list.size());

+        Queue queue = queueRepository.findByName(name);

 

-        if (list.size() == 0) {

+        if (queue == null) {

             throw new RollbackException("No such queue: '" + name + "'.");

         }

 

-        Queue queue = list.get(0);

-

-        entityManager.detach(query);

+        entityManager.detach(queue);

 

         return new JpaQueueRef(queue);

     }

 

     @Transactional

-    public JpaExecutionRef schedule(JpaQueueRef queue) {

-        return null;

+    public JpaExecutionRef schedule(JpaQueueRef queue, String... args) {

+        log.info("schedule: ENTER");

+        Date scheduled = new Date();

+        Task task = new Task(queue.queue, scheduled, args);

+        log.info("task = {}", task);

+        taskRepository.save(task);

+        log.info("task = {}", task);

+//        entityManager.detach(task);

+        log.info("schedule: LEAVE");

+        return new JpaExecutionRef(task);

     }

 

-    static class JpaQueueRef implements AsyncService.QueueRef {

+    public static class JpaQueueRef implements AsyncService.QueueRef {

         public final Queue queue;

 

         JpaQueueRef(Queue queue) {

             this.queue = queue;

         }

-    }

 

-    static class JpaExecutionRef implements AsyncService.ExecutionRef {

+        public String toString() {

+            return "JpaQueueRef{" +

+                    "queue=" + queue +

+                    '}';

+        }

     }

 

-    public static class AsyncServiceJob implements Job {

-        private final Logger log = LoggerFactory.getLogger(getClass());

+    public static class JpaExecutionRef implements AsyncService.ExecutionRef {

+        private final Task task;

 

-        public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {

-            try {

-                log.info("Running");

+        public JpaExecutionRef(Task task) {

+            this.task = task;

+        }

 

-                Context context = (Context) jobExecutionContext.getScheduler().getContext().get("context");

+        public String toString() {

+            return "JpaExecutionRef{" +

+                    "task=" + task +

+                    '}';

+        }

+    }

 

-                for (Map.Entry<String, Object> entry : jobExecutionContext.getMergedJobDataMap().entrySet()) {

-                    log.info("{} = {}, class= {}", entry.getKey(), entry.getValue(), entry.getValue() != null ? entry.getValue().getClass() : "<null>");

-                }

+    private class CheckTimerTask implements Runnable {

+        private final AsyncCallable callable;

+        private final JpaQueueRef queueRef;

+

+        private CheckTimerTask(AsyncCallable callable, JpaQueueRef queueRef) {

+            this.callable = callable;

+            this.queueRef = queueRef;

+        }

+

+        public void run() {

+            log.info("JpaAsyncService$CheckTimerTask.run");

 

-                int index = jobExecutionContext.getMergedJobDataMap().getIntFromString("index");

-                AsyncCallable callable = context.callables.get(index);

+            List<Task> tasks = taskRepository.findByQueueAndCompletedIsNull(queueRef.queue);

 

-                log.info("Calling {}", callable);

-                callable.run();

+            System.out.println("tasks.size() = " + tasks.size());

 

-            } catch (Throwable e) {

-                log.warn("fail", e);

-//                throw new JobExecutionException(e, false);

+            try {

+                for (final Task task : tasks) {

+                    try {

+                        executeTask(task);

+                    } catch (TransactionException e) {

+                        log.warn("Task execution failed", e);

+                    }

+                }

+            } catch (Exception e) {

+                log.warn("Error while execution tasks.", e);

             }

         }

+

+        private void executeTask(final Task task) {

+            final Date run = new Date();

+            log.info("Setting last run on task. date = {}, task = {}", run, task);

+            transactionTemplate.execute(new TransactionCallbackWithoutResult() {

+                protected void doInTransactionWithoutResult(TransactionStatus status) {

+                    task.registerRun();

+                    taskRepository.save(task);

+                }

+            });

+

+            transactionTemplate.execute(new TransactionCallbackWithoutResult() {

+                protected void doInTransactionWithoutResult(TransactionStatus status) {

+                    try {

+                        callable.run();

+                        Date completed = new Date();

+                        log.info("Setting completed on task. date = {}, task = {}", completed, task);

+                        task.registerComplete(completed);

+                        taskRepository.save(task);

+                    } catch (Exception e) {

+                        throw new RuntimeException("Error while executing callback", e);

+                    }

+                }

+            });

+        }

     }

 

-    public static class JpaDataSourceJobStore extends JobStoreSupport {

+    private class MyTransactionSynchronization implements TransactionSynchronization {

+

+        private final AsyncCallable callable;

 

-        public JpaDataSourceJobStore() {

-            setDataSource("wat");

+        private final int interval;

+

+        private final JpaQueueRef queueRef;

+

+        public MyTransactionSynchronization(AsyncCallable callable, int interval, JpaQueueRef queueRef) {

+            this.callable = callable;

+            this.interval = interval;

+            this.queueRef = queueRef;

         }

 

-        protected Connection getNonManagedTXConnection() throws JobPersistenceException {

-//            DefaultTransactionDefinition definition = new DefaultTransactionDefinition();

-//            definition.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);

-//            TransactionStatus transaction = transactionManagerStatic.getTransaction(definition);

+        public void suspend() {

+        }

 

-//            System.out.println("dataSourceStatic = " + dataSourceStatic);

-            Connection c = DataSourceUtils.getConnection(dataSourceStatic);

-            try {

-                c.setAutoCommit(false);

-            } catch (SQLException e) {

-                throw new RuntimeException(e);

-            }

-//            System.out.println("c = " + c);

+        public void resume() {

+        }

 

-            return c;

+        public void flush() {

         }

 

-        protected void closeConnection(Connection c) {

-            try {

-                DataSourceUtils.doCloseConnection(c, dataSourceStatic);

-            } catch (SQLException e) {

-                e.printStackTrace();

-            }

+        public void beforeCommit(boolean readOnly) {

+        }

 

+        public void beforeCompletion() {

         }

 

-        protected Object executeInLock(String lockName, TransactionCallback txCallback) throws JobPersistenceException {

-            return executeInNonManagedTXLock(lockName, txCallback);

+        public void afterCommit() {

+        }

+

+        public void afterCompletion(int status) {

+            log.info("status = {}", status);

+            if (status == TransactionSynchronization.STATUS_COMMITTED) {

+                executor.scheduleAtFixedRate(new CheckTimerTask(callable, queueRef), 1000, 1000 * interval, MILLISECONDS);

+            }

         }

     }

 }

diff --git a/src/main/java/io/trygvis/spring/Config.java b/src/main/java/io/trygvis/spring/Config.java
index 6bc8960..5df4dac 100755
--- a/src/main/java/io/trygvis/spring/Config.java
+++ b/src/main/java/io/trygvis/spring/Config.java
@@ -119,7 +119,7 @@ public class Config {
     @Bean

     public LocalContainerEntityManagerFactoryBean entityManagerFactory(DataSource dataSource,

                                                                        @Value("${hibernate.hbm2ddl.auto}") String hbm2ddl,

-                                                                       @Value("${hibernate.showSql}") boolean showSql,

+                                                                       @Value("${hibernate.showSql:false}") boolean showSql,

                                                                        @Value("${hibernate.dialect}") String dialect) {

         LocalContainerEntityManagerFactoryBean x = new LocalContainerEntityManagerFactoryBean();

         x.setDataSource(dataSource);

diff --git a/src/main/resources/logback.xml b/src/main/resources/logback.xml
index 5fa174f..39e3dbd 100755
--- a/src/main/resources/logback.xml
+++ b/src/main/resources/logback.xml
@@ -1,21 +1,15 @@
 <configuration debug="false">

 

   <logger name="io.trygvis" level="DEBUG"/>

-<!--

+<!-- <logger name="org.springframework" level="INFO"/> -->

   <logger name="org.springframework" level="INFO"/>

--->

-  <logger name="org.springframework" level="INFO"/>

-  <logger name="org.springframework.scheduling" level="DEBUG"/>

-  <logger name="org.springframework.jdbc.core.JdbcTemplate" level="DEBUG"/>

-  <logger name="org.hibernate" level="DEBUG"/>

-  <logger name="org.quartz" level="DEBUG"/>

-  <logger name="org.quartz.impl.jdbcjobstore.SimpleSemaphore" level="INFO"/>

-<!--

-  <logger name="org" level="INFO"/>

-  <logger name="net" level="INFO"/>

-  <logger name="com" level="INFO"/>

--->

-  <logger name="com.jolbox" level="DEBUG"/>

+  <logger name="org.springframework.jdbc" level="INFO"/>

+  <logger name="org.springframework.orm" level="INFO"/>

+

+  <logger name="org.hibernate" level="INFO"/>

+  <logger name="org.hibernate.SQL" level="INFO"/>

+

+  <logger name="com.jolbox" level="INFO"/>

 

   <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">

     <encoder>