That&#39;s the output of `git status`; git is showing you that after checking out `master` there are still uncommited changes to your working copy (one modified file and one deleted file).

Check `man git-status`:

    M = modified
    A = added
    D = deleted
    R = renamed
    C = copied
    U = updated but unmerged



I am getting this exception when I call a DAO method which uses `SessionFactory.getCurrentSession()`.  The DAO class is annotated with `@Transactional` and I also have `&lt;tx:annotation-driven/&gt;` declared in the application context configuration file.

I can call my DAO methods which perform HQL queries, but whenever I call a DAO method which first gets the Hibernate session then I run into this exception:

    SEVERE: Failed to save the object.
    org.hibernate.HibernateException: No Hibernate Session bound to thread, and configuration does not allow creation of non-transactional one here
    	at org.springframework.orm.hibernate3.SpringSessionContext.currentSession(SpringSessionContext.java:63)
    	at org.hibernate.impl.SessionFactoryImpl.getCurrentSession(SessionFactoryImpl.java:622)
    	at gov.noaa.ncdc.cmb.persistence.dao.GenericDaoHibernateImpl.getCurrentSession(GenericDaoHibernateImpl.java:56)
    	at gov.noaa.ncdc.cmb.persistence.dao.GenericDaoHibernateImpl.saveOrUpdate(GenericDaoHibernateImpl.java:187)


I have the following application context configuration file:

    &lt;?xml version=&quot;1.0&quot; encoding=&quot;UTF-8&quot;?&gt;
    &lt;beans xmlns=&quot;http://www.springframework.org/schema/beans&quot;
           xmlns:aop=&quot;http://www.springframework.org/schema/aop&quot;
           xmlns:flex=&quot;http://www.springframework.org/schema/flex&quot;
           xmlns:tx=&quot;http://www.springframework.org/schema/tx&quot;
           xmlns:xsi=&quot;http://www.w3.org/2001/XMLSchema-instance&quot;
           xsi:schemaLocation=&quot;http://www.springframework.org/schema/beans
                               http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
                               http://www.springframework.org/schema/flex
                               http://www.springframework.org/schema/flex/spring-flex-1.0.xsd
                               http://www.springframework.org/schema/tx
                               http://www.springframework.org/schema/tx/spring-tx-2.0.xsd&quot;&gt;
        
        &lt;!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ --&gt;
        &lt;!--  load values used for bean properties  --&gt;
        &lt;!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ --&gt;
        &lt;bean class=&quot;org.springframework.beans.factory.config.PropertyPlaceholderConfigurer&quot;&gt;
            &lt;property name=&quot;locations&quot;&gt;
                &lt;value&gt;applicationContext.properties&lt;/value&gt;
            &lt;/property&gt;
        &lt;/bean&gt;
    
    
        &lt;!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ --&gt;
        &lt;!--  DataSource where objects will be persisted  --&gt;
        &lt;!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ --&gt;
        &lt;bean id=&quot;dataSource&quot; class=&quot;org.springframework.jdbc.datasource.DriverManagerDataSource&quot;&gt;
            &lt;property name=&quot;username&quot; value=&quot;${datasource.username}&quot; /&gt;
            &lt;property name=&quot;password&quot; value=&quot;${datasource.password}&quot; /&gt;
            &lt;property name=&quot;url&quot; value=&quot;${datasource.url}&quot; /&gt;
            &lt;property name=&quot;driverClassName&quot; value=&quot;${datasource.driver}&quot; /&gt;
        &lt;/bean&gt;
    
    
        &lt;!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ --&gt;
        &lt;!-- Factory bean for Hibernate Sessions --&gt;
        &lt;!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ --&gt;
        &lt;bean id=&quot;hibernateSessionFactory&quot; class=&quot;org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean&quot;&gt;
            &lt;property name=&quot;dataSource&quot; ref=&quot;dataSource&quot; /&gt;
            &lt;property name=&quot;annotatedClasses&quot;&gt;
                &lt;list&gt;
                    &lt;value&gt;gov.noaa.ncdc.cmb.esrl.domain.entity.EsrlDailyAvg&lt;/value&gt;
                    &lt;value&gt;gov.noaa.ncdc.cmb.esrl.domain.entity.EsrlObservations&lt;/value&gt;
                    &lt;value&gt;gov.noaa.ncdc.cmb.esrl.domain.entity.EsrlStation&lt;/value&gt;
                &lt;/list&gt;
            &lt;/property&gt;
            &lt;property name=&quot;hibernateProperties&quot;&gt;
                &lt;props&gt;
                    &lt;prop key=&quot;hibernate.dialect&quot;&gt;${hibernate.dialect}&lt;/prop&gt;
                    &lt;prop key=&quot;hibernate.show_sql&quot;&gt;false&lt;/prop&gt;
                    &lt;prop key=&quot;hibernate.format_sql&quot;&gt;true&lt;/prop&gt;
                    &lt;prop key=&quot;hibernate.use_sql_comments&quot;&gt;true&lt;/prop&gt;
                    &lt;prop key=&quot;hibernate.jdbc.batch_size&quot;&gt;50&lt;/prop&gt;
                    &lt;prop key=&quot;hibernate.query.substitutions&quot;&gt;true 1, false 0&lt;/prop&gt;
                    &lt;prop key=&quot;hibernate.max_fetch_depth&quot;&gt;6&lt;/prop&gt;
                    &lt;prop key=&quot;hibernate.hbm2ddl.auto&quot;&gt;${hibernate.hbm2ddlauto}&lt;/prop&gt;
                    &lt;prop key=&quot;hibernate.cache.use_second_level_cache&quot;&gt;${hibernate.use_second_level_cache}&lt;/prop&gt;
                &lt;/props&gt;
            &lt;/property&gt;
        &lt;/bean&gt;
    
    
        &lt;!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~ --&gt;
        &lt;!--  Transaction Manager bean  --&gt;
        &lt;!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~ --&gt;
        &lt;bean id=&quot;transactionManager&quot; class=&quot;org.springframework.orm.hibernate3.HibernateTransactionManager&quot;&gt;
            &lt;property name=&quot;sessionFactory&quot; ref=&quot;hibernateSessionFactory&quot; /&gt;
        &lt;/bean&gt;
    
    
        &lt;!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ --&gt;
        &lt;!--  enable the configuration of transactional behavior based on annotations  --&gt;
        &lt;!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ --&gt;
        &lt;tx:annotation-driven transaction-manager=&quot;transactionManager&quot; /&gt;
    
    
        &lt;!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ --&gt;
        &lt;!--  DAO for ESRL Station objects  --&gt;
        &lt;!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ --&gt;
        &lt;bean id=&quot;esrlStationDao&quot; class=&quot;gov.noaa.ncdc.cmb.esrl.domain.dao.EsrlStationDaoHibernateImpl&quot;&gt;
            &lt;property name=&quot;sessionFactory&quot; ref=&quot;hibernateSessionFactory&quot; /&gt;
            &lt;property name=&quot;persistentClass&quot; value=&quot;gov.noaa.ncdc.cmb.esrl.domain.entity.EsrlStation&quot; /&gt;
        &lt;/bean&gt;
    
    
        &lt;!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ --&gt;
        &lt;!--  DAO for ESRL Observations objects  --&gt;
        &lt;!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ --&gt;
        &lt;bean id=&quot;esrlObservationsDao&quot; class=&quot;gov.noaa.ncdc.cmb.esrl.domain.dao.EsrlObservationsDaoHibernateImpl&quot;&gt;
            &lt;property name=&quot;sessionFactory&quot; ref=&quot;hibernateSessionFactory&quot; /&gt;
            &lt;property name=&quot;persistentClass&quot; value=&quot;gov.noaa.ncdc.cmb.esrl.domain.entity.EsrlObservations&quot; /&gt;
        &lt;/bean&gt;
    
    
        &lt;!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ --&gt;
        &lt;!--  DAO for ESRL daily average objects  --&gt;
        &lt;!-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ --&gt;
        &lt;bean id=&quot;esrlDailyAvgDao&quot; class=&quot;gov.noaa.ncdc.cmb.esrl.domain.dao.EsrlDailyAvgDaoHibernateImpl&quot;&gt;
            &lt;property name=&quot;sessionFactory&quot; ref=&quot;hibernateSessionFactory&quot; /&gt;
            &lt;property name=&quot;persistentClass&quot; value=&quot;gov.noaa.ncdc.cmb.esrl.domain.entity.EsrlDailyAvg&quot; /&gt;
        &lt;/bean&gt;
    
    
    &lt;/beans&gt; 

The generic DAO class (from which the DAO being used in my program is extended) looks like this:

    package gov.noaa.ncdc.cmb.persistence.dao;
    
    import gov.noaa.ncdc.cmb.persistence.entity.PersistentEntity;
    import java.io.Serializable;
    import java.util.Collection;
    import java.util.Date;
    import java.util.List;
    import org.apache.commons.logging.Log;
    import org.apache.commons.logging.LogFactory;
    import org.hibernate.Criteria;
    import org.hibernate.Session;
    import org.hibernate.SessionFactory;
    import org.hibernate.criterion.Criterion;
    import org.hibernate.criterion.Example;
    
    /**
     * This class is an implementation of GenericDao&lt;T, PK&gt; using Hibernate.
     */
    public class GenericDaoHibernateImpl&lt;T extends PersistentEntity&lt;PK&gt;, PK extends Serializable&gt;
        implements GenericDao&lt;T, PK&gt;
    {
        private SessionFactory sessionFactory;
    
        static private Log log = LogFactory.getLog(GenericDaoHibernateImpl.class);
    
        private Class&lt;T&gt; persistentClass;
    
        /**
         * Can be used within subclasses as a convenience method.
         * 
         * @param criterionList the criteria to find by
         * @return the list of elements that match the specified criteria
         */
        protected List&lt;T&gt; findByCriteria(final List&lt;Criterion&gt; criterionList)
        {
            Criteria criteria = getCurrentSession().createCriteria(persistentClass);
            for (Criterion criterion : criterionList)
            {
                criteria.add(criterion);
            }
            return criteria.list();
        }
    
        protected String getCanonicalPersistentClassName()
        {
            return persistentClass.getCanonicalName();
        }
    
        /**
         * Gets the current Hibernate Session object.
         * 
         * @return
         */
        protected Session getCurrentSession()
        {
            return sessionFactory.getCurrentSession();
        }
    
        /*
         * This method only provided for interface compatibility.  Not recommended for use with large batches 
         * (this is an inefficient implementation, and it&#39;s somewhat difficult to perform batch operations with Hibernate).
         * 
         * (non-Javadoc)
         * @see gov.noaa.ncdc.cmb.persistence.dao.GenericDao#batchInsert(java.util.Collection)
         */
        @Override
        public int[] batchInsert(final Collection&lt;T&gt; entityCollection)
        {
            int[] updateCounts = new int[entityCollection.size()];
            int i = 0;
            for (T entity : entityCollection)
            {
                try
                {
                    saveOrUpdate(entity);
                    updateCounts[i] = 1;
                    i++;
                }
                catch (Exception ex)
                {
                    clear();
                    throw new RuntimeException(ex);
                }
            }
            flush();
            clear();
    
            return updateCounts;
        }
    
        /*
         * This method only provided for interface compatibility.  Not recommended for use with large batches 
         * (this is an inefficient implementation, and it&#39;s somewhat difficult to perform batch operations with Hibernate).
         * 
         * (non-Javadoc)
         * @see gov.noaa.ncdc.cmb.persistence.dao.GenericDao#batchUpdate(java.util.Collection)
         */
        @Override
        public int[] batchUpdate(final Collection&lt;T&gt; entityCollection)
        {
            return batchInsert(entityCollection);
        }
    
        /**
         * Completely clear the session. Evict all loaded instances and cancel all pending saves, updates and deletions. Do
         * not close open iterators or instances of ScrollableResults.
         */
        public void clear()
        {
            getCurrentSession().clear();
        }
    
        /*
         * (non-Javadoc)
         * @see gov.noaa.ncdc.cmb.persistence.dao.GenericDao#delete(gov.noaa.ncdc.cmb.persistence.entity.PersistentEntity)
         */
        @Override
        public void delete(final T persistentObject)
        {
            getCurrentSession().delete(persistentObject);
        }
    
        /*
         * (non-Javadoc)
         * @see gov.noaa.ncdc.cmb.persistence.dao.GenericDao#findAll()
         */
        @Override
        public List&lt;T&gt; findAll()
        {
            return getCurrentSession().createQuery(&quot;from &quot; + persistentClass.getName()).list();
        }
    
        /**
         * Finds a collection of entity objects which match to the example instance, minus any specified properties which should be excluded from the matching.
         * 
         * @param exampleInstance
         * @param excludeProperty
         * @return
         */
        public List&lt;T&gt; findByExample(final T exampleInstance,
                                     final String[] excludeProperty)
        {
            Criteria criteria = getCurrentSession().createCriteria(persistentClass);
            Example example = Example.create(exampleInstance);
            if (excludeProperty != null)
            {
                for (String exclude : excludeProperty)
                {
                    example.excludeProperty(exclude);
                }
            }
            criteria.add(example);
            return criteria.list();
        }
    
        /*
         * (non-Javadoc)
         * @see com.sun.cloud.lifecycle.core.persistence.dao.GenericDao#findById(java.io.Serializable)
         */
        @Override
        public T findById(final PK id)
        {
            return (T) getCurrentSession().load(persistentClass, id);
        }
    
        /**
         * Force this session to flush. Must be called at the end of a unit of work, before commiting the transaction and
         * closing the session (depending on flush-mode, Transaction.commit() calls this method).
         * 
         * Flushing is the process of synchronizing the underlying persistent store with persistable state held in memory.
         */
        public void flush()
        {
            getCurrentSession().flush();
        }
    
        /*
         * (non-Javadoc)
         * @see gov.noaa.ncdc.cmb.persistence.dao.GenericDao#saveOrUpdate(gov.noaa.ncdc.cmb.persistence.entity.PersistentEntity)
         */
        @Override
        public T saveOrUpdate(final T entity)
        {
            try
            {
                entity.setUpdatedDate(new Date());
                getCurrentSession().saveOrUpdate(entity);
                return entity;
            }
            catch (Exception ex)
            {
                String errorMessage = &quot;Failed to save the object.&quot;;
                log.error(errorMessage, ex);
                throw new RuntimeException(errorMessage, ex);
            }
        }
    
        /**
         * Setter for the persistentClass property.
         * 
         * @param persistentClass
         */
        public void setPersistentClass(final Class&lt;T&gt; persistentClass)
        {
            this.persistentClass = persistentClass;
        }
    
        /**
         * Property setter.
         * 
         * @param sessionFactory
         */
        public void setSessionFactory(final SessionFactory sessionFactory)
        {
            this.sessionFactory = sessionFactory;
        }
    
    }

My application gets the DAO from the application context:

    // load the Spring application context, get the DAOs
    ApplicationContext applicationContext = new ClassPathXmlApplicationContext(new String[] { &quot;dailyAveragingApplicationContext.xml&quot; });
    esrlDailyAvgDao = (EsrlDailyAvgDao) applicationContext.getBean(&quot;esrlDailyAvgDao&quot;);
    esrlObservationsDao = (EsrlObservationsDao) applicationContext.getBean(&quot;esrlObservationsDao&quot;);


And the exception is encountered when I try to save an entity:

    esrlDailyAvgDao.saveOrUpdate(esrlDailyAvg);

The DAO class itself uses the Transactional annotation:
    
    @Transactional
    public class EsrlDailyAvgDaoHibernateImpl
        extends GenericDaoHibernateImpl&lt;EsrlDailyAvg, Long&gt;
        implements EsrlDailyAvgDao

The exception stack trace looks like this:

    SEVERE: Failed to save the object.
    org.hibernate.HibernateException: No Hibernate Session bound to thread, and configuration does not allow creation of non-transactional one here
    	at org.springframework.orm.hibernate3.SpringSessionContext.currentSession(SpringSessionContext.java:63)
    	at org.hibernate.impl.SessionFactoryImpl.getCurrentSession(SessionFactoryImpl.java:622)
    	at gov.noaa.ncdc.cmb.persistence.dao.GenericDaoHibernateImpl.getCurrentSession(GenericDaoHibernateImpl.java:56)
    	at gov.noaa.ncdc.cmb.persistence.dao.GenericDaoHibernateImpl.saveOrUpdate(GenericDaoHibernateImpl.java:187)
    	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    	at sun.reflect.NativeMethodAccessorImpl.invoke(Unknown Source)
    	at sun.reflect.DelegatingMethodAccessorImpl.invoke(Unknown Source)
    	at java.lang.reflect.Method.invoke(Unknown Source)
    	at org.springframework.aop.support.AopUtils.invokeJoinpointUsingReflection(AopUtils.java:309)
    	at org.springframework.aop.framework.JdkDynamicAopProxy.invoke(JdkDynamicAopProxy.java:196)
    	at $Proxy19.saveOrUpdate(Unknown Source)
    	at gov.noaa.ncdc.cmb.esrl.ingest.EsrlDailyAvgProcessor.main(EsrlDailyAvgProcessor.java:469)



No Hibernate Session bound to thread, and configuration does not allow creation of non-transactional one here

We use the Java preferences in some of our apps and haven&#39;t really noticed this since the utility that makes the calls is fairly old and was written in Windows XP days. But it seems the Java preferences are no longer stored in the registry in Windows 7 - or they are stored somewhere different. 

I&#39;m expecting it to be in:

`HKEY_LOCAL_MACHINE\SOFTWARE\JavaSoft\Prefs`

But I don&#39;t see it there.

What makes it wierder, is that when I run this app:

	public static void main( final String[] args ) throws BackingStoreException {

		Preferences systemRoot = Preferences.systemRoot();
		Preferences preferences = systemRoot.node( &quot;com/mycompany/settings&quot; );

		systemRoot.put( &quot;foo&quot;, &quot;bar&quot; );
		systemRoot.put( &quot;baz&quot;, &quot;lolz&quot; );
		System.out.println( &quot;-------------------------------&quot; );

		String[] keys = preferences.keys();
		for( String key : keys ) {
			System.out.println( key );
		}

		System.out.println( &quot;-------------------------------&quot; );

		keys = systemRoot.keys();
		for( String key : keys ) {
			System.out.println( key );
		}
	}

It actually writes (I can comment the put out and run it again and it works) but I don&#39;t see the new keys in the registry.

Also, I can&#39;t seem to see this documented anywhere. Thanks in advance.

**EDIT #1** The only reason this matters is that the setting changes dependent upon which environment it is ran. This being said, it is often useful to simulate that environment by inserting the registry keys manually and then doing some checking.

I was running as admin, yet I did not see the keys in the registry where I expected them to be.

Where are the Java preferences stored in Windows 7?

When I checkout, I get:

    me@localhost# git checkout master
    D    deps/example
    M    deps/example2
    Switched to branch &quot;master&quot;

The man page doesn&#39;t mention this cryptic output. What does it mean?

git checkout: what does this weird output mean?

When I checkout, I get:
<pre><code class="hljs language-bash">me@localhost# git checkout master
D deps/example
M deps/example2
Switched to branch "master"
</code></pre>
The man page doesn't mention this cryptic output. What does it mean?

I know I can do `git branch --all`, and that shows me both local and remote branches, but it&#39;s not that useful in showing me the relationships between them.

How do I list branches in a way that shows which local branch is tracking which remote?


How can I see which Git branches are tracking which remote / upstream branch?

[The official Git doc][1] says:


&gt; `$ git diff test`
&gt;
&gt; This will show you what is different between your current working directory and the snapshot on the &#39;test&#39; branch



As a newbie this is very confusing. I&#39;ve never heard of the term snapshot. Do they mean the &quot;HEAD&quot; of the &quot;test&quot; branch?

  [1]: http://schacon.github.io/gitbook/3_comparing_commits_-_git_diff.html

What is a git &quot;Snapshot&quot;?

I just did a 

    git commit -m &quot;blah&quot;

then I added some files, how do I rollback and remove what is in my current files that have not yet been added/committed?

Rollback to last git commit

I switched from Subversion to Git as my day-to-day VCS last year and am still trying to grasp the finer points of &quot;Git-think&quot;.

The one which has been bothering me lately is &quot;lightweight&quot; vs. annotated vs. signed tags.  It seems pretty universally accepted that annotated tags are superior to lightweight tags for all real uses, but the explanations I&#39;ve found for why that&#39;s the case always seem to boil down to either [&quot;because best practices&quot;](https://stackoverflow.com/questions/4092640/in-what-circumstances-should-i-add-the-a-flag-to-the-git-tag-command) or [&quot;because they&#39;re different&quot;](http://www.rockstarprogrammer.org/post/2008/oct/16/git-tag-does-wrong-thing-default/).  Unfortunately, those are very unsatisfying arguments without knowing *why* it&#39;s best practices or how those differences are *relevant* to my Git usage.

When I first switched to Git, lightweight tags seemed to be the best thing since sliced bread; I could just point at a commit and say &quot;that was 1.0&quot;.  I&#39;m having trouble grasping how a tag could ever need to be more than that, but I certainly can&#39;t believe that the Git experts of the world prefer annotated tags arbitrarily!  So what&#39;s all the hubbub about?

*(Bonus points: Why would I ever need to sign a tag?)*

**EDIT**

I&#39;ve been [successfully convinced](https://stackoverflow.com/questions/4971746/why-should-i-care-about-lightweight-vs-annotated-tags/4971817#4971817) that annotated tags are a Good Thing — knowing who tagged and when is important!  As a follow-up, any advice on good tag annotations?  Both `git tag -am &quot;tagging 1.0&quot; 1.0` and trying to summarize the commit log since the previous tag feel like losing strategies.

Why should I care about lightweight vs. annotated tags?

I have made a series of commits in Git and I realise now that I forgot to set my user name and user email properties correctly (new machine).  I have not yet pushed these commits to my repository, so how can I correct these commits before I do so (only the 3 latest commits on the master branch)?

I have been looking at `git reset` and `git commit -C &lt;id&gt; --reset-author`, but I don&#39;t think I&#39;m on the right track.

Content Type	Original Author	Original Content on Stackoverflow
Question	mwt	View Question on Stackoverflow
Solution 1 - Git	user229044	View Answer on Stackoverflow

git checkout: what does this weird output mean?

Git Problem Overview

Git Solutions

Solution 1 - Git

Where are the Java preferences stored in Windows 7?

No Hibernate Session bound to thread, and configuration does not allow creation of non-transactional one here

Attributions