[AJAX] Timeout ou trop de data, mais en erreur quoi qu'il en soit

Version imprimable

24/05/2010, 17h08
jak0

[AJAX] Timeout ou trop de data, mais en erreur quoi qu'il en soit

Bonjour à vous tous,

Je me tourne vers vous pour vos idées ou pistes concernant un comportement très bizarre en AJAX.
(C'est important de le préciser, j'utilise la librairie Prototype).
Depuis une simple page HTML, je fais une requête AJAX vers un script PHP. Ce PHP interroge une base de données et me retourne un certain nombre d'informations. Jusque là, c'est tout à fait classique.
Seulement voilà, ma requête SQL retourne un nombre moyen de lignes (de 10 à 20) mais avec 87 colonnes chacune.
Quand je limite (dans le SQL) à 12 lignes, pas de problème, je reçois bien la réponse AJAX. Quand je passe) à 13 lignes, hop plus de réponse et une exception lancée dans l'objet Ajax...
C'est systématiquement au delà de 12 que ça plante. J'ai essayé en mode texte (des appels directement vers le script PHP et tout fonctionne).

Est-ce que quelqu'un aurait une idée svp ?
Merci d'avance
24/05/2010, 17h41
jak0
J'ai réussi à mettre en place un mode débug et à comparer les différentes longueurs de chaînes renvoyées par mon PHP.
Code:

1 2 $json_data = json_encode ($my_data); print (strlen ($json_data));
A moins de 10 000, ça passe, à plus ça plante. Donc je pense que la réponse est là, mais comment contourner ? oO

bonsoir,

J'ai de mon coté fait des tests avec json_encode(). Pour ma part dans les résultats obtenu avec une extraction brute dans un array() mon fait flipper.

Je pense qu'il serait préférable que tu te tape a la paluche pour formaté json.
et ce pour respecté le standard.
Code:

1 2 3 4 5 {"nom extraction":[ {"champ1":"valeur1","champ2":"valeur2","champ3":"valeur3"} ,{"champ1":"valeur1","champ2":"valeur2","champ3":"valeur3"} ,{"champ1":"valeur1","champ2":"valeur2","champ3":"valeur3"} ]}
renvois une entête text/plain coté traitement serveur
coté client je ne connais pas prototype mais avec ton objet xmlhttprequest traite en responseText.

quelque soit la quantité de données existante le problème vient de ton formatage json.

bon courage

25/05/2010, 07h22
jak0

OK merci, je vais essayer l'encodage mano...
Je repost dans quelques heures
25/05/2010, 15h00
jak0

Effectivement en envoyant du text/plain et en récupérant le ResponsText, ça fonctionne.
Par contre, je ne comprend toujours pas pourquoi ça bloque en JSON
25/05/2010, 17h19
DoubleU

J'avais eu le même problème alors que je retournais une réponse xml, et j'avais utilisé le même genre de work around, c'est à dire récupérer le responseText pour regénérer le xml, plutot que passer par le responseXML.
25/05/2010, 21h59
burndev

tu renvois text/plain coté serveur formaté json est une chose
coté client tu récupère au format text mais ton traitement json tu le fait comment?

as tu regarder ceci, pour json avec proprotype.

montre moi un peu de code que je puisse comprendre

J'ai pas encore utilisé les paramètres de sécurité dispo dans cette page, mais je vais me pencher dessus.

Voilà ce que j'ai implémenté

Côté JavaScript, j'utilise ces deux objets :

Code:

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
function isset (variable) {
  return (typeof variable != 'undefined' && variable != null);
};
var JkAjaxRequester = Class.create();
JkAjaxRequester.request = function (arguments) {
  try {
    if (!isset (arguments)) throw ('JkAjaxRequester.request: arguments is null');
    if (!isset (arguments.requester)) throw ('JkAjaxRequester.request: No Respons Object');
    if (!isset (arguments.ajax_url)) throw ('JkAjaxRequester.request: No Ajax Id');
    JkAjaxRequester.ajaxBlinker (true);
    return new Ajax.Request (arguments.ajax_url, {
      method: 'post', 
      parameters: (isset (arguments.params) ? arguments.params : {}),
      requester: arguments.requester,
      timeout: false,
      onSuccess: function () {
        if (!isset (arguments [0].responseJSON)) {
          if (isset (arguments [0].responseText)) arguments [0].responseJSON = arguments [0].responseText.evalJSON (true);
        }
        if (!isset (arguments [0].responseJSON)) throw ('No answer from the server');
        JkAjaxRequester.responsFunction (
          new JkAjaxResponder ({
            flag: arguments [0].responseJSON.status.flag,
            code: arguments [0].responseJSON.status.code,
            message: arguments [0].responseJSON.status.message,
            returns: arguments [0].responseJSON,
            requester: arguments [0].request.options.requester
          })
        );
      },
      onFailure: function () {
        throw (arguments [0].status + ' ' + arguments [0].statusText);
      },
      onException: function () {
        JkAjaxRequester.responsFunction (
          new JkAjaxResponder ({
            flag: false,
            code: 1,
            message: "Error#1: Echec de la requ&ecirc;te",
            exception: arguments [1],
            requester: arguments [0].options.requester
          })
        );
      }
    });
  } catch (exception) {  
    JkAjaxRequester.responsFunction (
      new JkAjaxResponder ({
        flag: false,
        code: 2,
        message: "Error#2: Echec de la requ&ecirc;te",
        exception: exception,
        requester: arguments.requester
      })
    );
    return null;
  }
};
JkAjaxRequester.responsFunction = function (responder) {
  JkAjaxRequester.ajaxBlinker (false);
  if (isset (responder.requester.responsFunction)) responder.requester.responsFunction (responder);
};
JkAjaxRequester.ajax_timeout = null;
JkAjaxRequester.ajax_requests = 0;
JkAjaxRequester.ajaxBlinker = function (bool) {
  JkAjaxRequester.ajax_requests = JkAjaxRequester.ajax_requests + (bool ? 1 : -1);
  if (JkAjaxRequester.ajax_requests == 0 || (JkAjaxRequester.ajax_requests == 1 && bool)) {
    if (bool) {
      JkAjaxRequester.ajax_timeout = setTimeout ("document.body.className = 'loading';", 200);
    } else {
      clearTimeout (JkAjaxRequester.ajax_timeout); 
      document.body.className = '';
    }
  }
};
 
var JkAjaxResponder = Class.create ({
  initialize: function (arguments) {
    if (!isset (arguments)) throw ('JkAjaxResponder.initialize: arguments is null');
    this.flag = isset (arguments.flag) && arguments.flag == true;
    this.code = isset (arguments.code) ? arguments.code : -1;
    this.message = isset (arguments.message) ? arguments.message : "";
    this.exception = isset (arguments.exception) ? arguments.exception : null;
    this.returns = isset (arguments.returns) ? arguments.returns : null;
    this.requester = isset (arguments.requester) ? arguments.requester : null;
  },
  toString: function () {
    str = 'Object (JkAjaxResponder) : {';
      str += isset (this.flag) ? 'flag:'+this.flag+';' : '';
      str += isset (this.code) ? 'code:'+this.code+';' : '';
      str += isset (this.message) ? 'message:'+this.message+';' : '';
      str += isset (this.exception) ? 'exception:'+this.exception+';' : '';
      str += isset (this.returns) ? 'returns:'+this.returns+';' : '';
      str += isset (this.requester) ? 'requester:'+this.requester.toString()+';' : '';
    str += '}';
    return str;
  }
});

Côté PHP, en résumé, c'est ça :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
$RESPONSE_TEXT = isset ($_GET) && isset ($_GET ['text']);
$RESPONSE_JSON_LIMIT = 5000;
 
// [...]
 
$json_data = json_encode ($json_array);
if (strlen ($json_data) > $RESPONSE_JSON_LIMIT) $RESPONSE_TEXT = true;
 
if ($RESPONSE_TEXT) {
  header ('Content-type: text/plain');
  header ('Content-length: ' . strlen ($json_data));
  print  ("$json_data");
} else {
  header ('Content-type: application/x-json');
  header ('Content-length: ' . strlen ($json_data));
  header ("X-JSON: $json_data");
}

27/05/2010, 10h39
burndev

salut,
comme je te le disais au début, prototype reste le point noir pour moi.

est ce que l'encodage des datas(utf-8, ou autre) ne te ferais pas défaut quelque part. Car part rapport au premier post tu stipule bien qu'un certain nombre de lignes sont ok.

as tu essayé une extraction a partir de la ligne 13 a la fin(uniquement pour vérification).
28/05/2010, 20h58
jak0

A priori c'est pas une question de la ligne 13, mais bien de longueur de la réponse.
En changeant la façon dont je passe les réponses (tableaux, objets, etc), le nombre de ligne que je peux récupérer change mais pas la longueur de la réponse correspondante.