def stop(self, env):
    import params
    env.set_params(params)

    service('nodemanager',
            action='stop'
    )

  def start(self, env, rolling_restart=False):
    import params
    env.set_params(params)
    self.configure(env)

    supervisord_service("supervisor", action="start")
    service("logviewer", action="start")

  def start(self, env):
    import params
    env.set_params(params)
    self.configure(env)

    service("supervisor", action="start")
    service("logviewer", action="start")

 def start(self, env):
   import params
   env.set_params(params)
   self.configure(env)
   service('historyserver',
           action='start'
   )

 def start(self, env):
   import params
   env.set_params(params)
   self.configure(env) # FOR SECURITY
   service('jobtracker',
           action='start'
   )

    def start(self, env):
        import params

        env.set_params(params)
        self.configure(env)  # FOR SECURITY
        copy_tarballs_to_hdfs("mapreduce", params.mapred_user, params.hdfs_user, params.user_group)
        service("historyserver", action="start", serviceName="mapreduce")

  def start(self, env, rolling_restart=False):
    import params
    env.set_params(params)
    self.configure(env) # FOR SECURITY
    service('timelineserver', action='start')

    Links(params.new_yarn_log_path, params.yarn_log_path)

    def start(self, env):
        import params

        env.set_params(params)
        self.configure(env)

        service("drpc", action="start")

  def start(self, env):
    import params

    env.set_params(params)
    self.configure(env) # FOR SECURITY
    service('resourcemanager',
            action='start'
    )

  def stop(self, env, rolling_restart=False):
    import params

    env.set_params(params)

    service('resourcemanager',
            action='stop'
    )

  def start(self, env, rolling_restart=False):
    import params

    env.set_params(params)
    self.configure(env) # FOR SECURITY
    if params.has_ranger_admin and params.is_supported_yarn_ranger:
      setup_ranger_yarn() #Ranger Yarn Plugin related calls
    service('resourcemanager', action='start')

  def refreshqueues(self, env):
    import params

    self.configure(env)
    env.set_params(params)

    service('resourcemanager',
            action='refreshQueues'
    )

  def start(self, env, rolling_restart=False):
    import params
    env.set_params(params)
    self.configure(env) # FOR SECURITY
    service('nodemanager',action='start')

    Links(params.new_yarn_nodemanager_local_dirs_path, params.yarn_nodemanager_local_dirs_paths)
    Links(params.new_yarn_nodemanager_log_dirs_path, params.yarn_nodemanager_log_dirs_paths)
    Links(params.new_yarn_log_path, params.yarn_log_path)

  def start(self, env, upgrade_type=None):
    import params

    env.set_params(params)
    self.configure(env) # FOR SECURITY
    if params.has_ranger_admin and params.is_supported_yarn_ranger:
      setup_ranger_yarn() #Ranger Yarn Plugin related calls

    # wait for active-dir and done-dir to be created by ATS if needed
    if params.has_ats:
      Logger.info("Verifying DFS directories where ATS stores time line data for active and completed applications.")
      self.wait_for_dfs_directories_created(params.entity_groupfs_store_dir, params.entity_groupfs_active_dir)

    service('resourcemanager', action='start')

def main():
        
        config = ConfigParser.SafeConfigParser()
        config.read('/opt/raumServiceDeamon/src/deamon.cfg')
        
        dataPool = {'security': {'motion': False, 'door': False, 'motion_C': "CLOSED"}, 'weather': {'out': 0.0, 'rain': False, 'in': 0.0}}

        checkRRD(config)
        
        signal.signal(signal.SIGINT, kill_signal_handler)
        signal.signal(signal.SIGTERM, kill_signal_handler)
        
        #fillDummyData(dataPool) # DEBUG
        
        t = UploadDeamon(config, dataPool)
        t.start()

        tem = temperatur(config, dataPool)
        tem.start()
        
        sec = security(config, dataPool, t)
        sec.start()
        
        gra = graph(config)
        gra.start()
        
        global ser
        ser = service(dataPool)
        ser.start()

  def start(self, env, rolling_restart=False):
    import params
    env.set_params(params)
    self.configure(env) # FOR SECURITY

    if params.hdp_stack_version_major and compare_versions(params.hdp_stack_version_major, '2.2.0.0') >= 0:
      # MC Hammer said, "Can't touch this"
      resource_created = copy_to_hdfs("mapreduce", params.user_group, params.hdfs_user)
      resource_created = copy_to_hdfs("tez", params.user_group, params.hdfs_user) or resource_created
      if resource_created:
        params.HdfsResource(None, action="execute")
    else:
      # In HDP 2.1, tez.tar.gz was copied to a different folder in HDFS.
      install_tez_jars()

    service('historyserver', action='start', serviceName='mapreduce')

 def _channelInfoRequest(self):
     requestInfo = dict(part = "contentDetails,snippet,statistics")
     
     if self.mine:           requestInfo['mine'] = True
     elif self.channelId:    requestInfo['id'] = self.channelId
     else:                   requestInfo['forUsername'] = self.username
     
     request = service.service().channels().list(**requestInfo)
     return request 

 def getUpdateRequest(self):
     request = service.service().playlistItems().list(part="snippet", playlistId=self.id, maxResults=self.limit)
     
     def callback(request_id, response, exception):
         if exception is not None:
             raise ValueError('Exception thrown in update playlist videos http request from batch. Request ID: %s \nException: %s' %(request_id,exception))
         else:
             self._processUpdateResponse(response)
             
     return (request, callback)

def fetch():    
    request = service.service().guideCategories().list(part='snippet', regionCode=regionCode)
    response = request.execute()
    
    categories = []
        
    for item in response['items']:
        category = Category.fromCategoryList(item)
        categories.append(category)
        
    return categories

    def getInitialRequest(self):
        request = service.service().playlists().list(part = "snippet", id=self.id)
        
        def callback(request_id, response, exception):
            if exception is not None:
                raise ValueError(str.format('Exception thrown in initial playlist info http request from batch. \nRequest ID: {0}. Playlist ID: {1}. \nException: {2}', request_id, self.id, exception))
            else:
                self._processInitialResponse(response)
                

        return (request, callback)