We will start by importing the python socket module and creating a UDP connection to the server.

import socket
 
if __name__ == "__main__":
   sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
 
   # Connect to CoD4 server at 8.9.17.24:28960
   # Will also work for most other games in a similar fasion
   sock.connect(("8.9.17.24", 28960))

Now that we have established a connection with the game server, we may now start sending it rcon commands. Just remember that the protocol requires that you have a packet header of 0xFF0xFF0xFF0xFFrcon password where the password is replaced with your rcon password. You can then follow the packet header by the command you wish to run on the server. In this example we are simply going to print the server status.

	sock.send("\xFF\xFF\xFF\xFFrcon xxxxxxxxxx status")
	print sock.recv(65565)

Which will display a result similar to this:

����print
map: mp_broadcast
num score ping guid name lastmsg address qport rate
— —– —- ——————————– ————— ——- ——————— —– —–
0 262 137 666a7a82ac0897a213a3a220a1f59893 [0.o]BlameTruth^7 50 80.73.221.70:-8128 31736 25000
1 42 160 42e130756a877c36f71b4f25a96e07cd luluno^7 50 84.195.170.81:-2965 -30455 25000
2 52 36 829a446fd0b0d79f52d8adab5bbbe343 Zack^7 50 173.24.37.249:28960 22992 25000
3 642 31 d3aa0bf47f9c1734b2f7b21089ccafb9 Outlaw^7 0 76.228.193.186:28960 -11398 25000
4 142 110 c53129735bd532ada06d00289e7d609b Hasenpflug^7 50 24.7.31.6:28960 -5755 25000
5 392 96 f44087b315b41f77be8176664e4241f5 [KoS]Karma^7 50 76.14.127.157:28960 5397 25000
6 40 52 4dc7f80bea865494032e4dd782adac8d I Sketchy I^7 0 173.30.206.39:28960 -393 25000
7 0 152 f6aa1b9d5a9865b80e756f43674807e9 fRoz1n1^7 50 99.29.116.44:28960 -17501 25000
8 180 256 79ebdaf076b3301a7c2b95e109ca87d0 REBORN YEH^7 0 58.170.56.2:28960 23402 25000

Finally all you have to do is close the connection with sock.close() and the entirety of the code will look something like this:

import socket
 
if __name__ == "__main__":
	sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
 
	# Connect to CoD4 server at 8.9.17.24:28960
	# Will also work for most other games in a similar fasion
	sock.connect(("8.9.17.24", 28960))
	sock.send("\xFF\xFF\xFF\xFFrcon xxxxxxxxxx status")
	print sock.recv(65565)
	sock.close()

As noted, the Rcon protocol is extremely simple and its up to you to think of how you can use Rcon bots to improve the quality and functionality of your game servers. Just remember that you do not have to sock.recv() data from the server every time to send data and remember that the server may send data in chunks in which case you may not receive everything you need in one transmission. But overall its as simple as shown in this tutorial.

Now all we have to do is make a connection to Banshee via DBus and start calling methods. For this we will just use an interactive python interpreter which can be accessed by simply typing “python” at any command line prompt. Firstly, we will import the DBuslibrary.

import dbus

Next, we will make a connection to the session bus.

bus = dbus.SessionBus()

Then we will get Banshee’s PlayerEngine object which will let us control the player itself (Play, Pause, Next, Previous, Current Track, etc).

banshee = bus.get_object("org.bansheeproject.Banshee", "/org/bansheeproject/Banshee/PlayerEngine")

The first argument we pass, “org.bansheeproject.Banshee”, is the interface we want to connect to and “/org/bansheeproject/Banshee/PlayerEngine” is the path to the object that we want to use. Now we can start doing stuff with Banshee. You can pretty much take any of the methods listed in D-Feet and run them. For example:

banshee.Open("file:///home/maddog39/Music/Eisbrecher - Antikörper.mp3")

And to play the song…

banshee.Play()

Once you have had enough….

banshee.Pause()

Although note that you dont have to using the Open() method to use the Play() and Pause() methods, but Open() lets you open an arbitrary media file otherwise those other methods use the currently playing track. Now, to access properties you generally just take the name of the property and prepend ‘Get’ to it and make it a method. So for example:

banshee.GetCanPause()

Returns:

dbus.Boolean(False)

Or if we wanted to display all the information about the currently playing track we might do…

for key in currentTrack.keys():
	print key + ": " + str(currentTrack[key])

Which gives us:

album: Issues
rating: 0
name: Falling Away From Me
artist: Korn
URI: file:///home/maddog39/Music/Korn%20-%20Beating%20Me%20Down.mp3
length: 271.211
disc: 0
track-count: 16
year: 1999
track-number: 2

Another cool thing you can do with DBus is receive signals. What this allows us to do is run code when a given signal is triggered or received. We do this by connecting a python method with a signal on our bus. So if we wanted to do something every time Banshee changes its state (playing, paused, loading, loaded, etc) this is what would happen. We would first have to setup a main loop as it is required for a signals to function.

import gobject
from dbus.mainloop.glib import DBusGMainLoop
dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)

Then we would create a callback method which would be run every time the signal is triggered.

def stateChanged(state):
	print "State Changed: %s" % state

Now we can add our signal receiver to our method.

bus.add_signal_receiver(stateChanged,
dbus_interface="org.bansheeproject.Banshee.PlayerEngine",
                        signal_name="StateChanged")

Finally, at the end of a script that uses signals we would want to run our main loop.

gobject.MainLoop().run()

Well thats pretty much it! Just keep in mind that this was not intended to be a tutorial but merely a guideline on how to do interact and do things with Banshee over DBus. So feel free to sit down and write some of your own scripts based on what you have learned here and I hope this helps. I have already written my own program to integrate Banshee into another application which I will talk about in another article. Enjoy!

So this is a simple little tutorial on how to write a basic “Hello World” bot using PyBotlib. The library itself is only a single file so I have not bothered to repackage it or write setup scripts as you will only need import that single file within your application. You may get the latest source code for the library at any time here (google code/SVN) or here (blog). So here we go…

Lets start by defining our bot class and its constructor.

import botlib
 
# Create a new class for our bot, extending the Bot class from botlib
class HelloWorldBot(botlib.Bot):
    def __init__(self, server, channel, nick, password=None):
        botlib.Bot.__init__(self, server, 6667, channel, nick)
 
        # Send nickserv password if available
        if password != None:
            self.protocol.privmsg("nickserv", "identify" % password)

Next we are going to want to override the __actions__ function of the Bot class which will handle all of our bots actions. This acts as essentially a main loop and is called infinitely until the bot is shutdown. In here we put code for our commands, responders, whatever other interaction with the IRC channel that we need.

    def __actions__(self):
        botlib.Bot.__actions__(self)
 
        # Create a Hello World responder/command
        if botlib.check_found(self.data, "!hello"):
            # Get the senders username
            username = self.get_username()
 
            # Send user a message in response
            self.protocol.privmsg(self.channel, "Hello %s!" % username)

So here, we have created a simple command called !hello which runs the code underneath its if statement when an instance of that command is found in the chat. Then we call the get_username() function of the Bot class (remember that we inherited from the Bot class) to get the user name of the person who initiated the command. After that, we simply send a message back to the channel using the equivalent function for IRC’s PRIVMSG command. Now all we to do is instantiate and run our new bot.

 if __name__ == "__main__":
    # Create new instance of our bot and run it
    HelloWorldBot("irc.wyldryde.org", "#maddog39", "HelloWorldBot").run()

Keep in mind that when you are instantiating Bot object, that because PyBotlib is entirely threaded, you can make as many instances of your bot as you would like. I do have a BotManager class in PyBotlib intended for managing sets of multiple bots on the same process however I have never actually tested it so your results may vary. Here is the script in its entirety.

import botlib
 
# Create a new class for our bot, extending the Bot class from botlib
class HelloWorldBot(botlib.Bot):
    def __init__(self, server, channel, nick, password=None):
        botlib.Bot.__init__(self, server, 6667, channel, nick)
 
        # Send nickserv password if availible
        if password != None:
            self.protocol.privmsg("nickserv", "identify" % password)
 
    def __actions__(self):
        botlib.Bot.__actions__(self)
 
        # Create a Hello World responder/command
        if botlib.check_found(self.data, "!hello"):
            # Get the senders username
            username = self.get_username()
 
            # Send user a message in response
            self.protocol.privmsg(self.channel, "Hello %s!" % username)
 
if __name__ == "__main__":
    # Create new instance of our bot and run it
    HelloWorldBot("irc.wyldryde.org", "#maddog39", "HelloWorldBot").run()

Finally, to run your new bot, simply issue the command:

python helloworldbot.py

At the terminal prompt or command prompt (windows). Also note that you must make sure that your botlib.py file is in the same directory as your bot. Have fun!