/// <summary>
        /// Update Dropbox quota for Waveface
        /// </summary>
        /// <param name="quota"></param>
        /// <exception cref="Wammer.Station.Management.DropboxNotConnectedException">
        /// Waveface has not connected to Dropbox
        /// </exception>
        /// <exception cref="Wammer.Station.Management.DropboxNotInstalledException">
        /// Dropbox is not installed
        /// </exception>
        public static void UpdateDropbox(long quota)
        {
            try
            {
                if (!DropboxHelper.IsInstalled())
                {
                    throw new DropboxNotInstalledException("Dropbox is not installed");
                }

                CloudResponse res = CloudServer.request <CloudResponse>(
                    new WebClient(),
                    StationMgmtURL + "cloudstorage/dropbox/update",
                    new Dictionary <object, object> {
                    { "quota", quota }
                },
                    true
                    );
            }
            catch (Cloud.WammerCloudException e)
            {
                ExtractApiRetMsg(e);

                throw;
            }
        }
Пример #2
0
        public static void RespondFailure(HttpListenerResponse response, Exception e, int status)
        {
            CloudResponse json = new CloudResponse(status,
                                                   DateTime.Now.ToUniversalTime(), -1, e.Message);

            RespondFailure(response, json);
        }
        /// <summary>
        /// Connect Waveface to Dropbox
        /// </summary>
        /// <param name="quota"></param>
        /// <exception cref="Wammer.Station.Management.DropboxNoSyncFolderException">
        /// Dropbox sync folder does not exist
        /// </exception>
        /// <exception cref="Wammer.Station.Management.WrongAccountException">
        /// Link to inconsistent Dropbox account
        /// </exception>
        /// <exception cref="Wammer.Station.Management.DropboxNotInstalledException">
        /// Dropbox is not installed
        /// </exception>
        public static void ConnectDropbox(long quota)
        {
            try
            {
                if (!DropboxHelper.IsInstalled())
                {
                    throw new DropboxNotInstalledException("Dropbox is not installed");
                }

                string        folder = DropboxHelper.GetSyncFolder();
                CloudResponse res    = CloudServer.request <CloudResponse>(
                    new WebClient(),
                    StationMgmtURL + "cloudstorage/dropbox/connect",
                    new Dictionary <object, object> {
                    { "quota", quota }, { "folder", folder }
                },
                    true
                    );
            }
            catch (Cloud.WammerCloudException e)
            {
                ExtractApiRetMsg(e);

                throw;
            }
        }
        public void TestBypassException_pathWithQueryString()
        {
            using (HttpServer proxyServer = new HttpServer(80))
            {
                proxyServer.AddHandler("/", new MyHandler("dummy"));                 // dummy
                BypassHttpHandler bypasser = new BypassHttpHandler("http://localhost:8080");
                bypasser.AddExceptPrefix("/bypass/");
                proxyServer.AddDefaultHandler(bypasser);
                proxyServer.Start();

                WebClient agent = new WebClient();
                try
                {
                    agent.DownloadData("http://localhost:80/bypass?abc=123");
                }
                catch (WebException e)
                {
                    Assert.AreEqual(WebExceptionStatus.ProtocolError, e.Status);
                    using (StreamReader r = new StreamReader(e.Response.GetResponseStream()))
                    {
                        string        json = r.ReadToEnd();
                        CloudResponse resp = fastJSON.JSON.Instance.ToObject <CloudResponse>(json);
                        Assert.AreEqual(-1, resp.api_ret_code);
                        Assert.AreEqual(403, resp.status);
                        Assert.AreEqual("Station does not support this REST API; only Cloud does",
                                        resp.api_ret_message);
                    }
                    return;
                }

                Assert.Fail("Expected exception is not thrown");
            }
        }
Пример #5
0
        public void TestGetAttachmentInfo_NoObjectId()
        {
            WebClient agent = new WebClient();

            try
            {
                string output = agent.DownloadString("http://localhost:8080/api/get");
            }
            catch (WebException e)
            {
                HttpWebResponse res = (HttpWebResponse)e.Response;
                Assert.AreEqual(HttpStatusCode.BadRequest, res.StatusCode);

                using (StreamReader r = new StreamReader(res.GetResponseStream()))
                {
                    CloudResponse json = fastJSON.JSON.Instance.ToObject <CloudResponse>(
                        r.ReadToEnd());
                    Assert.AreEqual(-1, json.api_ret_code);
                    Assert.AreEqual((int)HttpStatusCode.BadRequest, json.status);
                    Assert.AreEqual("missing parameter: object_id", json.api_ret_message);
                }
                return;
            }
            Assert.Fail("expected error is not thrown");
        }
Пример #6
0
        private void OnCloud_CloudResponse(Datagram datagram)
        {
            CloudResponse response = datagram.UnSerialData <CloudResponse>();

            if (RunningDatas.RequestTable.TryGetValue(datagram.RequestID, out RequestSender value))
            {
                value.RequestCallback(response);
            }
        }
Пример #7
0
        public static void RespondFailure(HttpListenerResponse response, WammerStationException e, int status)
        {
            CloudResponse json = null;

            if (e.ErrorResponse != null)
            {
                json = e.ErrorResponse;
            }
            else
            {
                json = new CloudResponse(status, DateTime.Now.ToUniversalTime(), e.WammerError, e.Message);
            }

            RespondFailure(response, json);
        }
        /// <summary>
        /// Disconnect Waveface from Dropbox
        /// </summary>
        public static void DisconnectDropbox()
        {
            try
            {
                CloudResponse res = CloudServer.request <CloudResponse>(
                    new WebClient(),
                    StationMgmtURL + "cloudstorage/dropbox/disconnect",
                    new Dictionary <object, object>(),
                    true
                    );
            }
            catch (Cloud.WammerCloudException e)
            {
                ExtractApiRetMsg(e);

                throw;
            }
        }
Пример #9
0
        public static void RespondFailure(HttpListenerResponse response, CloudResponse json)
        {
            try
            {
                string resText = json.ToFastJSON();

                response.StatusCode  = json.status;
                response.ContentType = "application/json";

                using (StreamWriter w = new StreamWriter(response.OutputStream))
                {
                    w.Write(resText);
                }
            }
            catch (Exception ex)
            {
                logger.Error("Unable to respond failure", ex);
            }
        }
Пример #10
0
 internal DeviceInfo(CloudResponse response)
     : this(ResponseType.Cloud)
 {
     ServerVersion   = response.ApiVersion;
     WurflLastUpdate = _baseDate.AddSeconds(response.MTime);
     Id = response.Id;
     foreach (var c in response.Capabilities)
     {
         Capabilities.Add(c.Key, c.Value);
         string value;
         if (!Capabilities.TryGetValue(c.Key, out value))
         {
             Errors.Add("Exception", String.Format("The {0} capability is not currently available", c.Key));
         }
     }
     foreach (var e in response.Errors)
     {
         Errors.Add(e.Key, e.Value);
     }
 }
Пример #11
0
        private void OnCloudRequest(Datagram datagram)
        {
            CloudRequest request = datagram.UnSerialData <CloudRequest>();

            CloudResponse response = new CloudResponse();

            response.Files.AddRange
            (
                InfoReader.ReadAll
                (
                    IKXTServer.DataConvert.GetString(datagram.Sender),
                    request.Path
                )
            );

            datagram.DataType    = DatagramType.Client;
            datagram.MessageType = CloudDatagramDefine.CloudResponse;

            byte[][] buffer = response.ToByteArrays();
            for (int i = 0; i < buffer.Length; ++i)
            {
                datagram.Datas = buffer[i];
                if (!Send(datagram.ToByteArray()))
                {
                    Notify(IKXTServer.LogLevel.Error, "数据发送异常");
                    Close();
                    return;
                }
            }

            datagram.MessageType = CloudDatagramDefine.CloudResFinish;
            datagram.Datas       = null;
            if (!Send(datagram.ToByteArray()))
            {
                Notify(IKXTServer.LogLevel.Error, "数据发送异常");
                Close();
            }
        }
Пример #12
0
        public void HandleRequest(HttpListenerRequest origReq, HttpListenerResponse response)
        {
            logger.Debug("Forward to cloud: " + origReq.Url.AbsolutePath);
            try
            {
                if (HasNotAllowedPrefix(origReq.Url.AbsolutePath))
                {
                    CloudResponse json = new CloudResponse(403, -1,
                                                           "Station does not support this REST API; only Cloud does");
                    HttpHelper.RespondFailure(response, json);
                }

                Uri            targetUri = GetTargetUri(origReq);
                HttpWebRequest newReq    = (HttpWebRequest)WebRequest.Create(targetUri);

                CopyRequestHeaders(origReq, newReq);

                if (origReq.HasEntityBody)
                {
                    newReq.BeginGetRequestStream(RequestStreamGotten,
                                                 new BypassContext(origReq, response, newReq));
                }
                else
                {
                    newReq.BeginGetResponse(ResponseGotten, new BypassContext(origReq, response, newReq));
                }
            }
            catch (WebException e)
            {
                logger.Error("forward to cloud error", e);
                ReplyCloudError(response, e);
            }
            catch (Exception e)
            {
                logger.Error("Forward to cloud error", e);
                HttpHelper.RespondFailure(response, e, 400);
            }
        }
        public void TestView_NoObjectID()
        {
            using (HttpServer server = new HttpServer(80))
            {
                server.AddHandler("/v1/objects/view", new AttachmentViewHandler("sid"));
                server.Start();

                HttpWebRequest req = (HttpWebRequest)WebRequest.Create(
                    "http://localhost/v1/objects/view");
                req.Method = "GET";

                try
                {
                    req.GetResponse();
                }
                catch (WebException e)
                {
                    Assert.AreEqual(WebExceptionStatus.ProtocolError, e.Status);
                    HttpWebResponse response = (HttpWebResponse)e.Response;
                    Assert.AreEqual("application/json", response.ContentType);

                    using (StreamReader reader = new StreamReader(response.GetResponseStream()))
                    {
                        string responseText = reader.ReadToEnd();

                        CloudResponse res = fastJSON.JSON.Instance.ToObject <CloudResponse>(responseText);
                        Assert.AreEqual(400, res.status);
                        Assert.AreEqual(-1, res.api_ret_code);
                        Assert.AreEqual("missing required param: object_id", res.api_ret_message);
                    }

                    return;
                }

                Assert.Fail("Expected failure is not thrown");
            }
        }