summaryrefslogtreecommitdiff
path: root/vndbApi.ml
blob: dac59d0b26cb3f215a05ee53b48248235c9c30f8 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160

open Unix


type reply =
    RInvalid of string (* unable to parse reply for some reason (string=raw reply) *)
  | ROK
  | RResults of (int * bool * Json.json list) (* num, more, items *)
  | RError of (string * string * Json.json)   (* id, msg, json obj *)


class connection
    (pollfunc : file_descr -> bool -> (unit -> unit) -> unit)
    (waitfunc : int -> (unit -> unit) -> unit)
  = object (self)
  val mutable s_sock = (None : file_descr option) (* None when disconnected *)
  val mutable s_host = "beta.vndb.org"
  val mutable s_port = 19534
  val mutable s_addr = (None : inet_addr option)
  val mutable linefunc = (None : (bool -> string -> unit) option)
  val cmd_queue = (Queue.create () : (string * (reply -> unit)) Queue.t)
  val mutable cmd_running = false


  method get_host = s_host
  method set_host h = s_host <- h
  method get_port = s_port
  method set_port p = s_port <- p
  method get_addr = s_addr
  method set_linefunc f = linefunc <- f
  method connected = match s_sock with None -> false | Some _ -> true


  method private parsereply str =
    try
      (* space and newline are always ignored with scanf, so no need to check
       * for that. (this parser is rather lazy, and may accept incorrect input) *)
      let name, value =
        Scanf.sscanf str "%[\r\t] %[a-z] %[\r\t] %[^\004]" (fun _ a _ b -> (a,b)) in
      match name with
      | "ok" -> ROK
      | "error" -> 
        let obj = Json.json_of_string value in
        RError (
          Json.get_string (Json.get_value obj "id"),
          Json.get_string (Json.get_value obj "msg"),
          obj
        )
      | "results" ->
        let obj = Json.json_of_string value in
        RResults (
          int_of_string  (Json.get_int (Json.get_value obj "num")),
          Json.get_bool  (Json.get_value obj "more"),
          Json.get_array (Json.get_value obj "items")
        )
      | _ -> raise (Failure "Incorrect reply code")
    with _ -> RInvalid str
    (* the above try .. throws away any info on why it was invalid. but oh well,
     * it's not like the server will send invalid data anytime soon anyway *)


  method private docmd () =
    if (not cmd_running && not (Queue.is_empty cmd_queue) && s_sock <> None) then (
      cmd_running <- true;
      let cmd, recvcb = Queue.peek cmd_queue in
      let s = match s_sock with None -> assert false | Some x -> x in
      let reply = ref "" in
      let buf = String.create 8192 in
      let finish () =
        reply := String.sub !reply 0 (String.rindex !reply '\004');
        (match linefunc with None -> () | Some f -> f false !reply);
        let preply = self#parsereply !reply in
        match preply with
        (* Oops! throttled error, let's wait a few seconds and try again *)
        | RError ("throttled", _, obj) -> (
          let wait = match Json.get_value obj "minwait" with
          | Json.Int i -> int_of_string i
          | Json.Number n -> int_of_float (ceil (float_of_string n))
          | _ -> assert false in
          waitfunc wait (fun () ->
            cmd_running <- false;
            self#docmd ()
          ))
        (* Not throttled, so consider this command as finished *)
        | _ -> 
          ignore (Queue.pop cmd_queue);
          self#docmd ();
          recvcb preply
      in
      let rec dorecv () =
        let cnt = recv s buf 0 (String.length buf) [] in
        reply := !reply ^ (String.sub buf 0 cnt);
        match String.contains !reply '\004' with
        | true  -> finish ()
        | false -> pollfunc s true dorecv
      in
      let dosend () = 
        (* assumes the command can be sent with a single call *)
        let _ = send s
          (cmd ^ (String.make 1 (char_of_int 4)))
          0 (String.length cmd + 1) [] in
        match linefunc with None -> () | Some f -> f true cmd;
        pollfunc s true dorecv
      in
      pollfunc s false dosend
    )


  method addcmd cmd recvcb =
    Queue.push (cmd, recvcb) cmd_queue;
    self#docmd ()


  (* TODO: keep monitoring connection after successful connect *)
  method connect cf ff =
    (* get IP (blocks!) *)
    let ip = match s_addr with
    | Some x -> x
    | None -> (gethostbyname s_host).h_addr_list.(0) in
    (* create socket *)
    let s = socket PF_INET SOCK_STREAM 0 in
    (* and connect *)
    let success () =
      clear_nonblock s;
      s_sock <- Some s;
      s_addr <- Some ip;
      cf ip s_port in
    let failure a b c =
      close s;
      ff a b c in
    set_nonblock s;
    try
      ignore (connect s (ADDR_INET (ip, s_port)));
      (* no error? assume this was a successfull blocking connect *)
      success ()
    (* non-blocking connect, poll for the result *)
    with Unix_error (EINPROGRESS, _, _) ->
      pollfunc s false (fun () -> 
        clear_nonblock s;
        match getsockopt_error s with
        | None -> success ()
        | Some e -> failure e "connect" (error_message e)
      )
    (* blocking connect, but failed *)
    | Unix_error (a, b, c) -> failure a b c


  method login user pass recvcb =
    let o = Json.Object [
      ("protocol",  Json.Int    "1");
      ("client",    Json.String "Serika");
      ("clientver", Json.Number "0.1");
      ("username",  Json.String user);
      ("password",  Json.String pass)
    ] in
    self#addcmd ("login " ^ (Json.string_of_json o)) recvcb

end