Changeset 847536504b95307eadfdb31d17902c85569e2e21

Timestamp:

03/01/10 02:12:12 (5 months ago)

Author:

Nedko Arnaudov <nedko@…>

Children:

945b3aa6865654fd54707c298636a428c6510755

Parents:

e897f8a983f2f752ee61bfbfb296986b23726fb6

git-committer:

Nedko Arnaudov <nedko@arnaudov.name> / 2010-03-01T02:12:12Z+0200

Message:

Basic control of studio rooms

Files:

• daemon/control.c (modified) (3 diffs)
• daemon/control.h (modified) (2 diffs)
• daemon/room.c (modified) (4 diffs)
• daemon/room.h (modified) (2 diffs)
• daemon/studio.c (modified) (3 diffs)
• ladish_control (modified) (3 diffs)

daemon/control.c

@@ -49 +49 @@
   ladish_room_handle room;
 
-  if (!ladish_room_create(empty_room, "Empty", &room))
+  if (!ladish_room_create(empty_room, "Empty", NULL, &room))
   {
     log_error("ladish_room_create() failed.");
@@ -57 +57 @@
   list_add_tail(ladish_room_get_list_node(room), &g_rooms);
 
-  if (!ladish_room_create(basic_room, "Basic", &room))
+  if (!ladish_room_create(basic_room, "Basic", NULL, &room))
   {
     log_error("ladish_room_create() failed.");
@@ -122 +122 @@
 
   return true;
+}
+
+ladish_room_handle find_room_template_by_name(const char * name)
+{
+  ladish_room_handle room;
+  struct list_head * node_ptr;
+
+  maybe_create_rooms();
+
+  list_for_each(node_ptr, &g_rooms)
+  {
+    room = ladish_room_from_list_node(node_ptr);
+    if (strcmp(ladish_room_get_name(room), name) == 0)
+    {
+      return room;
+    }
+  }
+
+  return NULL;
+}
+
+ladish_room_handle find_room_template_by_uuid(const uuid_t uuid_ptr)
+{
+  ladish_room_handle room;
+  struct list_head * node_ptr;
+  uuid_t uuid;
+
+  maybe_create_rooms();
+
+  list_for_each(node_ptr, &g_rooms)
+  {
+    room = ladish_room_from_list_node(node_ptr);
+    ladish_room_get_uuid(room, uuid);
+    if (uuid_compare(uuid, uuid_ptr) == 0)
+    {
+      return room;
+    }
+  }
+
+  return NULL;
 }
 

daemon/control.h

@@ -29 +29 @@
 #define __LASHD_DBUS_IFACE_CONTROL_H__
 
+#include "room.h"
+
 extern const struct dbus_interface_descriptor g_lashd_interface_control;
 
@@ -37 +39 @@
 bool rooms_init(void);
 void rooms_uninit(void);
+ladish_room_handle find_room_template_by_name(const char * name);
+ladish_room_handle find_room_template_by_uuid(const uuid_t uuid_ptr);
 
 #endif /* __LASHD_DBUS_IFACE_CONTROL_H__ */

daemon/room.c

@@ -32 +32 @@
   uuid_t uuid;
   char * name;
+  uuid_t template_uuid;
 };
 
@@ -38 +39 @@
   const uuid_t uuid_ptr,
   const char * name,
+  ladish_room_handle template,
   ladish_room_handle * room_handle_ptr)
 {
@@ -51 +53 @@
   if (uuid_ptr == NULL)
   {
-    uuid_generate(room_ptr->uuid);
+    if (template == NULL)
+    {
+      uuid_generate(room_ptr->uuid);
+    }
+    else
+    {
+      ladish_room_get_uuid(template, room_ptr->uuid);
+    }
   }
   else
   {
     uuid_copy(room_ptr->uuid, uuid_ptr);
+  }
+
+  if (template != NULL)
+  {
+    ladish_room_get_uuid(template, room_ptr->template_uuid);
+  }
+  else
+  {
+    uuid_clear(room_ptr->template_uuid);
   }
 
@@ -90 +108 @@
 }
 
+bool ladish_room_get_template_uuid(ladish_room_handle room_handle, uuid_t uuid_ptr)
+{
+  if (uuid_is_null(room_ptr->template_uuid))
+  {
+    return false;
+  }
+
+  uuid_copy(uuid_ptr, room_ptr->template_uuid);
+  return true;
+}
+
+void ladish_room_get_uuid(ladish_room_handle room_handle, uuid_t uuid_ptr)
+{
+  uuid_copy(uuid_ptr, room_ptr->uuid);
+}
+
 #undef room_ptr
 

daemon/room.h

@@ -36 +36 @@
   const uuid_t uuid_ptr,
   const char * name,
+  ladish_room_handle template,
   ladish_room_handle * room_handle_ptr);
 
@@ -46 +47 @@
 
 const char * ladish_room_get_name(ladish_room_handle room_handle);
+bool ladish_room_get_template_uuid(ladish_room_handle room_handle, uuid_t uuid_ptr);
+void ladish_room_get_uuid(ladish_room_handle room_handle, uuid_t uuid_ptr);
 
 #endif /* #ifndef ROOM_H__9A1CF253_0A17_402A_BDF8_9BD72B467118__INCLUDED */

daemon/studio.c

@@ -696 +696 @@
 }
 
+static void ladish_studio_new_room(struct dbus_method_call * call_ptr)
+{
+  const char * room_name;
+  const char * template_name;
+  ladish_room_handle room;
+
+  dbus_error_init(&g_dbus_error);
+
+  if (!dbus_message_get_args(call_ptr->message, &g_dbus_error, DBUS_TYPE_STRING, &room_name, DBUS_TYPE_STRING, &template_name, DBUS_TYPE_INVALID))
+  {
+    lash_dbus_error(call_ptr, LASH_DBUS_ERROR_INVALID_ARGS, "Invalid arguments to method \"%s\": %s",  call_ptr->method_name, g_dbus_error.message);
+    dbus_error_free(&g_dbus_error);
+    return;
+  }
+
+  log_info("Request to create new studio room \"%s\" from template \"%s\".", room_name, template_name);
+
+  room = find_room_template_by_name(template_name);
+  if (room == NULL)
+  {
+    lash_dbus_error(call_ptr, LASH_DBUS_ERROR_INVALID_ARGS, "Unknown room template \"%s\"",  template_name);
+    return;
+  }
+
+  if (!ladish_room_create(NULL, room_name, room, &room))
+  {
+    lash_dbus_error(call_ptr, LASH_DBUS_ERROR_GENERIC, "ladish_room_create() failed.");
+    return;
+  }
+
+  list_add_tail(ladish_room_get_list_node(room), &g_studio.rooms);
+
+  //dbus_signal_emit(g_dbus_connection, STUDIO_OBJECT_PATH, IFACE_STUDIO, "RoomAppeared", "");
+
+  method_return_new_void(call_ptr);
+}
+
+static void ladish_studio_get_room_list(struct dbus_method_call * call_ptr)
+{
+  DBusMessageIter iter, array_iter;
+  DBusMessageIter struct_iter;
+  DBusMessageIter dict_iter;
+  struct list_head * node_ptr;
+  ladish_room_handle room;
+  const char * name;
+  uuid_t template_uuid;
+  ladish_room_handle template;
+  const char * template_name;
+
+  call_ptr->reply = dbus_message_new_method_return(call_ptr->message);
+  if (call_ptr->reply == NULL)
+  {
+    goto fail;
+  }
+
+  dbus_message_iter_init_append(call_ptr->reply, &iter);
+
+  if (!dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "(sa{sv})", &array_iter))
+  {
+    goto fail_unref;
+  }
+
+  list_for_each(node_ptr, &g_studio.rooms)
+  {
+    room = ladish_room_from_list_node(node_ptr);
+    name = ladish_room_get_name(room);
+
+    if (!ladish_room_get_template_uuid(room, template_uuid))
+    {
+      template = NULL;
+      template_name = NULL;
+    }
+    else
+    {
+      template = find_room_template_by_uuid(template_uuid);
+      if (template != NULL)
+      {
+        template_name = ladish_room_get_name(template);
+      }
+      else
+      {
+        template_name = NULL;
+      }
+    }
+
+    if (!dbus_message_iter_open_container(&array_iter, DBUS_TYPE_STRUCT, NULL, &struct_iter))
+      goto fail_unref;
+
+    if (!dbus_message_iter_append_basic(&struct_iter, DBUS_TYPE_STRING, &name))
+      goto fail_unref;
+
+    if (!dbus_message_iter_open_container(&struct_iter, DBUS_TYPE_ARRAY, "{sv}", &dict_iter))
+      goto fail_unref;
+
+    if (!dbus_maybe_add_dict_entry_string(&dict_iter, "template", template_name))
+      goto fail_unref;
+
+    if (!dbus_message_iter_close_container(&struct_iter, &dict_iter))
+      goto fail_unref;
+
+    if (!dbus_message_iter_close_container(&array_iter, &struct_iter))
+      goto fail_unref;
+  }
+
+  if (!dbus_message_iter_close_container(&iter, &array_iter))
+  {
+    goto fail_unref;
+  }
+
+  return;
+
+fail_unref:
+  dbus_message_unref(call_ptr->reply);
+  call_ptr->reply = NULL;
+
+fail:
+  log_error("Ran out of memory trying to construct method return");
+}
+
+static void ladish_studio_delete_room(struct dbus_method_call * call_ptr)
+{
+  const char * name;
+
+  dbus_error_init(&g_dbus_error);
+
+  if (!dbus_message_get_args(call_ptr->message, &g_dbus_error, DBUS_TYPE_STRING, &name, DBUS_TYPE_INVALID))
+  {
+    lash_dbus_error(call_ptr, LASH_DBUS_ERROR_INVALID_ARGS, "Invalid arguments to method \"%s\": %s",  call_ptr->method_name, g_dbus_error.message);
+    dbus_error_free(&g_dbus_error);
+    return;
+  }
+
+  log_info("Delete studio room request (%s)", name);
+
+  {
+    method_return_new_void(call_ptr);
+  }
+}
+
 METHOD_ARGS_BEGIN(GetName, "Get studio name")
   METHOD_ARG_DESCRIBE_OUT("studio_name", "s", "Name of studio")
@@ -722 +861 @@
 METHOD_ARGS_BEGIN(IsStarted, "Check whether studio is started")
   METHOD_ARG_DESCRIBE_OUT("started", "b", "Whether studio is started")
+METHOD_ARGS_END
+
+METHOD_ARGS_BEGIN(NewRoom, "New studio room")
+  METHOD_ARG_DESCRIBE_IN("room_name", "s", "Studio room name")
+  METHOD_ARG_DESCRIBE_IN("room_template_name", "s", "Room template name")
+METHOD_ARGS_END
+
+METHOD_ARGS_BEGIN(GetRoomList, "Get list of rooms in this studio")
+  METHOD_ARG_DESCRIBE_OUT("room_list", "a(sa{sv})", "List of studio rooms, name and properties")
+METHOD_ARGS_END
+
+METHOD_ARGS_BEGIN(DeleteRoom, "Delete studio room")
+  METHOD_ARG_DESCRIBE_IN("room_name", "s", "Name of studio room to delete")
 METHOD_ARGS_END
 
@@ -733 +885 @@
   METHOD_DESCRIBE(Stop, ladish_stop_studio)
   METHOD_DESCRIBE(IsStarted, ladish_studio_is_started)
+  METHOD_DESCRIBE(NewRoom, ladish_studio_new_room)
+  METHOD_DESCRIBE(GetRoomList, ladish_studio_get_room_list)
+  METHOD_DESCRIBE(DeleteRoom, ladish_studio_delete_room)
 METHODS_END
 

ladish_control

@@ -114 +114 @@
         print("    rdel <roomname>      - delete room")
         print("    rnew <roomname>      - new room")
+        print("    snewroom <name> <tname> - new studio room")
+        print("    srlist               - list studio rooms")
+        print("    sdelroom <name>      - delete studio room")
         sys.exit(0)
     
@@ -203 +206 @@
                 print("--- room delete")
                 if index >= len(sys.argv):
-                    print("delete room command requires studio name argument")
+                    print("delete room command requires room name argument")
                     sys.exit()
 
@@ -242 +245 @@
                     print("--- studio stop")
                     studio_iface.Stop()
+                elif arg == 'snewroom':
+                    print("--- new studio room")
+                    if index + 1 >= len(sys.argv):
+                        print("creation of studio room requires room name and room template name arguments")
+                        sys.exit()
+
+                    room_name = sys.argv[index]
+                    index += 1
+                    room_template_name = sys.argv[index]
+                    index += 1
+
+                    studio_iface.NewRoom(room_name, room_template_name)
+                elif arg == 'srlist':
+                    print("--- studio room list")
+                    for room in studio_iface.GetRoomList():
+                        #print repr(room)
+                        name = room[0]
+                        if room[1].has_key("template"):
+                            template = str(room[1]["template"])
+                        else:
+                            template = None
+
+                        if template:
+                            print('"%s" from template "%s"' % (name, template))
+                        else:
+                            print('"%s"' % name)
+                elif arg == 'sdelroom':
+                    print("--- studio room delete")
+                    if index >= len(sys.argv):
+                        print("delete studio room command requires room name argument")
+                        sys.exit()
+
+                    arg = sys.argv[index]
+                    index += 1
+
+                    studio_iface.DeleteRoom(arg)
                 else:
                     print("Unknown command '%s'" % arg)