diff --git a/examples/hosts_file/hosts.py b/examples/hosts_file/hosts.py
index 1533a17e..f6aba5d3 100644
--- a/examples/hosts_file/hosts.py
+++ b/examples/hosts_file/hosts.py
@@ -20,22 +20,22 @@ def run():
 
     hosts1 = vr.create('hosts_file1', 'resources/hosts_file', {})[0]
     hosts2 = vr.create('hosts_file2', 'resources/hosts_file', {})[0]
-    signals.connect(node1, hosts1, {
+    node1.connect(hosts1, {
         'name': 'hosts:name',
         'ip': 'hosts:ip',
     })
 
-    signals.connect(node2, hosts2, {
+    node2.connect(hosts1, {
         'name': 'hosts:name',
         'ip': 'hosts:ip',
     })
 
-    signals.connect(node1, hosts2, {
+    node1.connect(hosts2, {
         'name': 'hosts:name',
         'ip': 'hosts:ip',
     })
 
-    signals.connect(node2, hosts1, {
+    node2.connect(hosts2, {
         'name': 'hosts:name',
         'ip': 'hosts:ip',
     })
diff --git a/examples/riak/riaks.py b/examples/riak/riaks.py
index 7f02e12b..3fdf704c 100755
--- a/examples/riak/riaks.py
+++ b/examples/riak/riaks.py
@@ -48,10 +48,10 @@ def setup_riak():
         riak_services.append(r)
 
     for i, riak in enumerate(riak_services):
-        signals.connect(nodes[i], riak)
+        nodes[i].connect(riak)
 
     for i, riak in enumerate(riak_services[1:]):
-        signals.connect(riak_services[0], riak, {'riak_name': 'join_to'})
+        riak_services[0].connect(riak, {'riak_name': 'join_to'})
 
     hosts_services = []
     for i, riak in enumerate(riak_services):
@@ -59,14 +59,13 @@ def setup_riak():
         hosts_file = vr.create('hosts_file%d' % num,
                                'resources/hosts_file', {})[0]
         hosts_services.append(hosts_file)
-        signals.connect(nodes[i], hosts_file)
+        nodes[i].connect(hosts_file)
 
     for riak in riak_services:
         for hosts_file in hosts_services:
-            signals.connect(riak, hosts_file,
-                            {'riak_hostname': 'hosts:name',
-                             'ip': 'hosts:ip'},
-                            events=False)
+            riak.connect_with_events(hosts_file,
+                {'riak_hostname': 'hosts:name',
+                 'ip': 'hosts:ip'})
 
     errors = resource.validate_resources()
     for r, error in errors:
@@ -142,24 +141,26 @@ def setup_haproxies():
 
     for single_hpsc in hpsc_http:
         for riak in riaks:
-            signals.connect(riak, single_hpsc, {'riak_hostname': 'backends:server',
-                                                'riak_port_http': 'backends:port'})
+            riak.connect(single_hpsc, {
+                'riak_hostname': 'backends:server',
+                'riak_port_http': 'backends:port'})
 
     for single_hpsc in hpsc_pb:
         for riak in riaks:
-            signals.connect(riak, single_hpsc, {'riak_hostname': 'backends:server',
-                                                'riak_port_pb': 'backends:port'})
+            riak.connect(single_hpsc,
+                {'riak_hostname': 'backends:server',
+                 'riak_port_pb': 'backends:port'})
 
     # haproxy config to haproxy service
 
     for single_hpc, single_hpsc in zip(hpc, hpsc_http):
-        signals.connect(single_hpsc, single_hpc, {"backends": "config:backends",
+        single_hpsc.connect(single_hpc, {"backends": "config:backends",
                                                   "listen_port": "config:listen_port",
                                                   "protocol": "config:protocol",
                                                   "name": "config:name"})
 
     for single_hpc, single_hpsc in zip(hpc, hpsc_pb):
-        signals.connect(single_hpsc, single_hpc, {"backends": "config:backends",
+        single_hpsc.connect(single_hpc, {"backends": "config:backends",
                                                   "listen_port": "config:listen_port",
                                                   "protocol": "config:protocol",
                                                   "name": "config:name"})
@@ -173,10 +174,10 @@ def setup_haproxies():
     nodes = [node1, node2, node3]
 
     for single_node, single_hps in zip(nodes, hps):
-        signals.connect(single_node, single_hps)
+        single_node.connect(single_hps)
 
     for single_node, single_hpc in zip(nodes, hpc):
-        signals.connect(single_node, single_hpc)
+        single_node.connect(single_hpc)
 
     has_errors = False
     for r in locals().values():
diff --git a/examples/solard/example.py b/examples/solard/example.py
index 01737e75..74726442 100644
--- a/examples/solard/example.py
+++ b/examples/solard/example.py
@@ -32,29 +32,27 @@ def run():
                                   {'solard_user': 'vagrant',
                                    'solard_password': 'password'})[0]
 
-    signals.connect(transports_for_solard, solard_transport, {})
-
-    signals.connect(ssh_transport, transports_for_solard, {'ssh_key': 'transports:key',
-                                                               'ssh_user': 'transports:user',
-                                                               'ssh_port': 'transports:port',
-                                                               'name': 'transports:name'})
+    transports_for_solard.connect(solard_transport, {})
+    ssh_transport.connect(transports_for_solard,{'ssh_key': 'transports:key',
+                                                 'ssh_user': 'transports:user',
+                                                 'ssh_port': 'transports:port',
+                                                 'name': 'transports:name'})
     # set transports_id
-    signals.connect(transports, node, {})
+    transports.connect(node, {})
 
     # it uses reverse mappings
-    signals.connect(ssh_transport, transports, {'ssh_key': 'transports:key',
-                                                'ssh_user': 'transports:user',
-                                                'ssh_port': 'transports:port',
-                                                'name': 'transports:name'})
-
-    signals.connect(solard_transport, transports, {'solard_user': 'transports:user',
-                                                   'solard_port': 'transports:port',
-                                                   'solard_password': 'transports:password',
-                                                   'name': 'transports:name'})
+    ssh_transport.connect(transports, {'ssh_key': 'transports:key',
+                                        'ssh_user': 'transports:user',
+                                        'ssh_port': 'transports:port',
+                                        'name': 'transports:name'})
+    solard_transport.connect(transports, {'solard_user': 'transports:user',
+                                           'solard_port': 'transports:port',
+                                           'solard_password': 'transports:password',
+                                           'name': 'transports:name'})
 
 
     hosts = vr.create('hosts_file', 'resources/hosts_file', {})[0]
-    signals.connect(node, hosts, {
+    node.connect(hosts, {
         'ip': 'hosts:ip',
         'name': 'hosts:name'
     })
diff --git a/solar/solar/core/resource/resource.py b/solar/solar/core/resource/resource.py
index 3a18777b..f7427714 100644
--- a/solar/solar/core/resource/resource.py
+++ b/solar/solar/core/resource/resource.py
@@ -23,6 +23,8 @@ from solar import utils
 
 from solar.core import validation
 from solar.interfaces import orm
+from solar.core import signals
+from solar.events import api
 
 from uuid import uuid4
 from hashlib import md5
@@ -248,6 +250,19 @@ class Resource(object):
     def load_commited(self):
         return orm.DBCommitedState.get_or_create(self.name)
 
+    def connect_with_events(self, receiver, mapping=None, events=None,
+            use_defaults=False):
+        signals.connect(self, receiver, mapping=mapping)
+        if use_defaults:
+            api.add_default_events(self, receiver)
+        if events:
+            api.add_events(self.name, events)
+
+    def connect(self, receiver, mapping=None, events=None):
+        return self.connect_with_events(
+            receiver, mapping=mapping, events=events, use_defaults=True)
+
+
 
 def load(name):
     r = orm.DBResource.load(name)
diff --git a/solar/solar/core/resource/virtual_resource.py b/solar/solar/core/resource/virtual_resource.py
index 0063415e..357510d2 100644
--- a/solar/solar/core/resource/virtual_resource.py
+++ b/solar/solar/core/resource/virtual_resource.py
@@ -129,7 +129,7 @@ def create_resources(resources, tags=None):
             if node:
                 node = load_resource(node)
                 r = new_resources[0]
-                signals.connect(node, r, {})
+                node.connect(r, mapping={})
                 r.add_tags('location={}'.format(node.name))
             update_inputs(resource_name, args)
     return created_resources
@@ -167,8 +167,10 @@ def update_inputs(child, args):
         mapping = {}
         parent = load_resource(c['parent'])
         events = c['events']
+        use_defaults = not c['events'] is False
         mapping[c['parent_input']] = c['child_input']
-        signals.connect(parent, child, mapping, events)
+        parent.connect_with_events(
+            child, mapping, events, use_defaults=use_defaults)
 
     child.update(assignments)
 
diff --git a/solar/solar/core/signals.py b/solar/solar/core/signals.py
index 5a7681af..0ddce5d6 100644
--- a/solar/solar/core/signals.py
+++ b/solar/solar/core/signals.py
@@ -16,8 +16,6 @@
 import networkx
 
 from solar.core.log import log
-from solar.events.api import add_events
-from solar.events.controls import Dependency
 from solar.interfaces import orm
 
 
@@ -129,7 +127,7 @@ def location_and_transports(emitter, receiver, orig_mapping):
     return
 
 
-def connect(emitter, receiver, mapping=None, events=None):
+def connect(emitter, receiver, mapping=None):
     if mapping is None:
         mapping = guess_mapping(emitter, receiver)
 
@@ -146,18 +144,6 @@ def connect(emitter, receiver, mapping=None, events=None):
         for d in dst:
             connect_single(emitter, src, receiver, d)
 
-    events_to_add = [
-        Dependency(emitter.name, 'run', 'success', receiver.name, 'run'),
-        Dependency(emitter.name, 'update', 'success', receiver.name, 'update')
-    ]
-    if isinstance(events, dict):
-        for k, v in events.items():
-            if v is not False:
-                events_to_add = filter(lambda x: x.parent_action == k, events_to_add)
-        add_events(emitter.name, events_to_add)
-    elif events is not False:
-        add_events(emitter.name, events_to_add)
-
 
 def connect_single(emitter, src, receiver, dst):
     if ':' in dst:
diff --git a/solar/solar/events/api.py b/solar/solar/events/api.py
index 12bae370..2a6780ee 100644
--- a/solar/solar/events/api.py
+++ b/solar/solar/events/api.py
@@ -37,6 +37,14 @@ def create_event(event_dict):
         raise Exception('No support for type %s', etype)
 
 
+def add_default_events(emitter, receiver):
+    events_to_add = [
+        Dep(emitter.name, 'run', 'success', receiver.name, 'run'),
+        Dep(emitter.name, 'update', 'success', receiver.name, 'update')
+    ]
+    add_events(emitter.name, events_to_add)
+
+
 def add_event(ev):
     rst = all_events(ev.parent)
     for rev in rst:
diff --git a/solar/solar/test/test_virtual_resource.py b/solar/solar/test/test_virtual_resource.py
index b625a639..8b107a7d 100644
--- a/solar/solar/test/test_virtual_resource.py
+++ b/solar/solar/test/test_virtual_resource.py
@@ -112,7 +112,7 @@ def test_parse_bad_event(bad_event_type):
 
 
 def test_add_connections(mocker, resources):
-    mocked_signals = mocker.patch('solar.core.resource.virtual_resource.signals')
+    mocked_signals = mocker.patch('solar.core.resource.resource.signals')
     args = {'ip': 'node1::ip',
             'servers': ['node1::ip', 'node2::ip'],
             'alias': 'ser1'