Say hello to the specified person.
198616
def execute_internal(_result)
      item = LogMessage.new
      parser = LogParser.new(@source, @sequence)
      sequences = {}
      # keep track of sequences, and when you complete one, then print out the 
      # entire thing at once.
      while parser.next(item)
        if item.kind?(ActionCommand::LOG_KIND_COMMAND_OUTPUT) && item.root?
          process_output(sequences, item)
        else
          process_other(sequences, item)
        end  
        item = LogMessage.new
      end
        
      # print out any incomplete sequences
      print_sequences(sequences)
    end
1373953
@GetMapping
    public ResponseEntity<Greeting> greetingSync(
            @RequestParam(value = "name", defaultValue = "World") String name) {
        return ResponseEntity.ok(new Greeting(String.format(template, name)));
    }
348916
async def handle_client_hello(self, client_addr, _: ClientHello):
        
        self._logger.info("New client connected %s", client_addr)
        self._registered_clients.add(client_addr)
        await self.send_container_update_to_client([client_addr])
245803
def do_invite(self, sender, body, args):
        """"""
        for invitee in args:
            new_member = { 'JID': invitee }
            self.invite_user(new_member, inviter=sender)
639260
def welcome(self, user):
        
        self.send_message(create_message('RoomServer', 'Please welcome {name} to the server!\nThere are currently {i} users online -\n {r}\n'.format(name=user.id, 
                          i=self.amount_of_users_connected, 
                          r=' '.join(self.user_names))))
        logging.debug('Welcoming user {user} to {room}'.format(user=user.id.name, room=self.name))
695646
public void greet(String name) {
    logger.info("Will try to greet " + name + " ...");
    HelloRequest request = HelloRequest.newBuilder().setName(name).build();
    HelloReply response;
    try {
      response = blockingStub.sayHello(request);
    } catch (StatusRuntimeException e) {
      logger.log(Level.WARNING, "RPC failed: {0}", e.getStatus());
      return;
    }
    logger.info("Greeting: " + response.getMessage());
  }
637017
def Greeting(self, Username=''):
        
        for v in self.Voicemails:
            if Username and v.PartnerHandle != Username:
                continue
            if v.Type in (vmtDefaultGreeting, vmtCustomGreeting):
                return v
200668
def system_greet(input_params={}, always_retry=True, **kwargs):
    
    return DXHTTPRequest('/system/greet', input_params, always_retry=always_retry, **kwargs)
933938
def on_connect(client):
    
    print "++ Opened connection to %s" % client.addrport()
    broadcast('%s joins the conversation.\n' % client.addrport() )
    CLIENT_LIST.append(client)
    client.send("Welcome to the Chat Server, %s.\n" % client.addrport() )
370521
def on_welcome(self, connection, event):
        
        # Start the pool
        self.__pool.start()

        logging.info("! Connected to server '%s': %s",
                     event.source, event.arguments[0])
        connection.join("#cohorte")
711840
function(type, obj) {
     switch (type) {
       case 'greet':
         var name = _.get(obj, 'profile.displayName') || _.get(obj, 'username', '') || obj;

         return _.get(name, 'length') ? name : 'Hey';
         break;
     }

     return obj; 
    }
1300564
function hello(req, res) {
  // variables defined in the Swagger document can be referenced using req.swagger.params.{parameter_name}
  var name = req.swagger.params.name.value || 'stranger';
  var hello = util.format('Hello, %s!', name);

  // this sends back a JSON response which is a single string
  res.json(hello);
}
608605
def do_welcome(self):
        
        self.rate_limited_send('join', self.config['core']['channel'])
        self.rate_limited_send('join', self.config['core']['ctrlchan'], self.config['auth']['ctrlkey'])
        # We use this to pick up info on admins who aren't currently in a channel.
        self.workers.defer(5, False, self.get_admins)
        extrachans = self.config['core']['extrachans']
        if extrachans:
            for chan in [x.strip() for x in extrachans.split(',')]:
                self.rate_limited_send('join', chan)
912349
async def ask(self, body, quick_replies=None, options=None, user=None):
        
        await self.send_text_message_to_all_interfaces(
            recipient=user,
            text=body,
            quick_replies=quick_replies,
            options=options,
        )
        return any.Any()
1124773
def acknowledge(self, size, msg):
        
        stream = self.router.stream_by_id(msg.src_id)
        state = self._state_by_stream[stream]
        state.lock.acquire()
        try:
            if state.unacked < size:
                LOG.error('%r.acknowledge(src_id %d): unacked=%d < size %d',
                          self, msg.src_id, state.unacked, size)
            state.unacked -= min(state.unacked, size)
            self._schedule_pending_unlocked(state)
        finally:
            state.lock.release()
621207
def start(self):
        
        self.connect()
        if not self.isAlive():
            super(WAMPClient,self).start()
        self.hello()
        return self
280202
def execute(self, email):
        """"""
        print('Sign up user {0}'.format(email))
        self.email_sender.send(email, 'Welcome, "{}"'.format(email))