コード例 #1
0
        public Dialog_ModSync_Window()
        {
            MSLog.Log("New window", MSLog.Level.All);
            try
            {
                CurrSyncState = CurrentSyncState.RequestStarted;
                ClientInternetConnectivity = InternetConnectivity.Unchecked;
                closeOnClickedOutside      = false;
                FetchRelevantMods();

                string userRequest = NetworkManager.GenerateServerRequestString(_relevantMods);
                _userRequestStr = Convert.ToBase64String(System.Text.Encoding.UTF8.GetBytes(userRequest));
                NetworkManager.CheckForInternetConnectionAsync(
                    this.ClientInternetConnectivity, (InternetConnectivity clientInternetConnectivity) =>
                {
                    this.ClientInternetConnectivity = clientInternetConnectivity;
                    this.OnNetworkConnectionTestCompleted();
                });
            }
            catch (Exception e)
            {
                MSLog.Log("ERROR:", MSLog.Level.All);
                MSLog.Log(e.Message, MSLog.Level.All);
            }
        }
コード例 #2
0
        public static void CheckForInternetConnectionAsync(
            Dialog_ModSync_Window.InternetConnectivity clientInternetConnectivity,
            CheckForInternetConnectionAsyncCallback callback)
        {
            new Thread(() =>
            {
                MSLog.Log("Checking for network async", MSLog.Level.All);
                try
                {
                    //user.OnNetworkConnectionTestCompleted();

                    var request     = WebRequest.Create("http://www.google.com");
                    request.Timeout = 5000;

                    request.BeginGetResponse((IAsyncResult result) =>
                    {
                        MSLog.Log("CheckForInternetConnectionAsyncCallback:", MSLog.Level.All);
                        var httpWebRequest = result.AsyncState as HttpWebRequest;
                        try
                        {
                            // Request finished
                            clientInternetConnectivity = (httpWebRequest == null || !httpWebRequest.HaveResponse)
                                ? Dialog_ModSync_Window.InternetConnectivity.Offline
                                : Dialog_ModSync_Window.InternetConnectivity.Online;
                            // Perform callback
                            callback(clientInternetConnectivity);
                        }
                        catch
                        {
                            MSLog.Log("failed to assign network check response, client probably closed window", MSLog.Level.All);
                        }
                    }, request);

                    // assume time out
                    try
                    {
                        Thread.Sleep(5000);
                        request.Abort();
                        MSLog.Log("Connection test request closed with connectivity state: " + clientInternetConnectivity, MSLog.Level.All);
                        if (clientInternetConnectivity != Dialog_ModSync_Window.InternetConnectivity.Online)
                        {
                            clientInternetConnectivity = Dialog_ModSync_Window.InternetConnectivity.Offline;
                            // Perform callback
                            callback(clientInternetConnectivity);
                        }
                    }
                    catch
                    {
                        MSLog.Log("network check timed out", MSLog.Level.All);
                    }
                }
                catch
                {
                    MSLog.Log("network check failed", MSLog.Level.All);
                }
            }).Start();
        }
コード例 #3
0
        private static bool OpenXmlFromAboutDir(DirectoryInfo rootDir, string xmlFileToOpen, FileAccess fileAccess, OpenXmlFromAboutDirCallback callback)
        {
            if (callback == null)
            {
                throw new Exception("callback cannot be null");
            }

            DirectoryInfo aboutDir = rootDir.GetDirectories(ABOUT_DIRECTORY).FirstOrDefault();

            if (aboutDir == null)
            {
                return(false);
            }

            FileInfo xmlFile = aboutDir.GetFiles(MOD_SYNC_XML).FirstOrDefault();

            if (xmlFile == null)
            {
                return(false);
            }

            try
            {
                using (FileStream fs = xmlFile.Open(FileMode.Open, fileAccess))
                {
                    XDocument xml = null;
                    using (StreamReader sr = new StreamReader(fs))
                    {
                        xml = XDocument.Parse(sr.ReadToEnd());
                        if (!xml.Elements().Any())
                        {
                            throw new Exception("Invalid markup, null elements");
                        }
                        string   rootElement = (ABOUT_XML.Equals(xmlFileToOpen)) ? ABOUT_ROOT_ELEMENT : MODSYNC_NINJA_ROOT_ELEMENT;
                        XElement root        = xml.Element(rootElement);
                        if (root == null)
                        {
                            throw new Exception("Invalid markup, missing root");
                        }
                        callback.Invoke(root);
                    }
                    if (xml != null &&
                        (fileAccess == FileAccess.ReadWrite || fileAccess == FileAccess.Write))
                    {
                        xml.Save(xmlFile.FullName);
                    }
                }
                return(true);
            }
            catch (Exception e)
            {
                MSLog.Log(xmlFileToOpen + ": " + e.Message, MSLog.Level.All, true);
                return(false);
            }
        }
        public override void PreOpen()
        {
            base.PreOpen();

            // Initialize UpdateModRequest
            this.about = FileUtil.GetAboutFileText(this.ModToUpdate.RootDir);
            if (String.IsNullOrEmpty(this.about))
            {
                MSLog.Log("Unable to find About.xml for " + this.ModToUpdate.Name, MSLog.Level.All, true);
                this.Close();
            }
            this.modId          = FileUtil.GetModSyncId(this.ModToUpdate.RootDir);
            this.modKey         = String.Empty;
            this.publishedField = FileUtil.GetSteamPublishedField(this.ModToUpdate.RootDir);
            this.version        = this.LocalVersion;
        }
コード例 #5
0
 public void OnNetworkConnectionTestCompleted()
 {
     // load data from server
     MSLog.Log("OnNetworkConnectionTestCompleted", MSLog.Level.All);
     if (ClientInternetConnectivity == InternetConnectivity.Online)
     {
         NetworkManager.CreateRequestHttpRequest(
             _userRequestStr,
             (CurrentSyncState syncState) => this.CurrSyncState = syncState,
             (string responseStr, bool success, string errorCode) =>
             this.OnRequestFromServerResponse(responseStr, success, errorCode));
     }
     else
     {
         CurrSyncState = CurrentSyncState.ClientOffline;
     }
 }
コード例 #6
0
        public static void CreateRequestHttpRequest(string userRequestStr, CreateHttpRequestSyncStateCallback syncStateCallback, CreateHttpRequestFinishedCallback finishedCallback)
        {
            new Thread(() =>
            {
                Thread.CurrentThread.IsBackground = true;
                HttpWebResponse response          = null;
                try
                {
                    if (syncStateCallback != null)
                    {
                        syncStateCallback.Invoke(Dialog_ModSync_Window.CurrentSyncState.RequestStarted);
                    }

                    // Create a request using a URL that can receive a post.
                    WebRequest request = WebRequest.Create(API);
                    // Set the Method property of the request to POST.
                    request.Method  = "POST";
                    request.Timeout = 20000;

                    // Create POST data and convert it to a byte array.
                    string postData = userRequestStr;
                    MSLog.Log("Sending request to server: " + postData);
                    byte[] byteArray = Encoding.UTF8.GetBytes(postData);
                    // Set the ContentType property of the WebRequest.
                    request.ContentType = "application/json; charset=utf-8";
                    // Set the ContentLength property of the WebRequest.
                    request.ContentLength = byteArray.Length;

                    // Get the request stream.
                    Stream dataStream = request.GetRequestStream();
                    // Write the data to the request stream.
                    dataStream.Write(byteArray, 0, byteArray.Length);
                    // Close the Stream object.
                    dataStream.Close();

                    // Get the response.
                    response = (HttpWebResponse)request.GetResponse();

                    dataStream = response.GetResponseStream();


                    StreamReader reader       = new StreamReader(dataStream);
                    string responseFromServer = reader.ReadToEnd();
                    responseFromServer        = responseFromServer.Trim('\"');
                    reader.Close();
                    dataStream.Close();
                    MSLog.Log("Connection closed with response:" + responseFromServer);
                    // 3 is the length of our error codes, since base64 length is base 4, no valid response will have a length of 3
                    if (!String.IsNullOrEmpty(responseFromServer) && responseFromServer.Length.Equals(3))
                    {
                        MSLog.Log("ModSync Ninja has encountered an error with your request if this error repeats, feel free to submit the error below to the forums", MSLog.Level.User);
                        MSLog.Log("Your request: " + userRequestStr, MSLog.Level.User);
                        MSLog.Log("Response Error: " + responseFromServer, MSLog.Level.User);
                        if (finishedCallback != null)
                        {
                            finishedCallback.Invoke(String.Empty, false, responseFromServer);
                        }
                    }
                    else if (finishedCallback != null)
                    {
                        finishedCallback.Invoke(responseFromServer, true);
                    }
                }
                catch (WebException e)
                {
                    bool showErrorWindow = true;
                    if (e.Status == WebExceptionStatus.ConnectFailure ||
                        e.Status == WebExceptionStatus.Timeout ||
                        e.Status == WebExceptionStatus.ConnectionClosed)
                    {
                        syncStateCallback(Dialog_ModSync_Window.CurrentSyncState.ModSyncOffline);
                        showErrorWindow = false;
                    }
                    MSLog.Log("ModSync Ninja has encountered an error with your request if this error repeats, feel free to submit the error below to the forums", MSLog.Level.User);
                    MSLog.Log("Your request: " + userRequestStr, MSLog.Level.User);
                    if (e.Status == WebExceptionStatus.ProtocolError)
                    {
                        response = (HttpWebResponse)e.Response;
                        MSLog.Log("Response Errorcode: " + (int)response.StatusCode, MSLog.Level.User);
                        if (finishedCallback != null)
                        {
                            finishedCallback.Invoke(String.Empty, false, response.StatusCode.ToString());
                        }
                    }
                    else
                    {
                        MSLog.Log("Response error: " + e.Status, MSLog.Level.User);
                        if (finishedCallback != null)
                        {
                            finishedCallback.Invoke(String.Empty, false, e.Status.ToString());
                        }
                    }
                    if (showErrorWindow)
                    {
                        MSLog.ShowErrorScreen();
                    }
                }
                finally
                {
                    if (response != null)
                    {
                        response.Close();
                    }
                }
            }).Start();
        }
コード例 #7
0
        public void OnRequestFromServerResponse(string responseStr, bool success, string errorCode = "")
        {
            MSLog.Log("OnRequestFromServerResponse, GOT: response:" + responseStr + "\nSuccess: " + success + "\nErrorCode: " + errorCode);
            if (!success)
            {
                // server not offline, this is a real error
                if (CurrSyncState != CurrentSyncState.ModSyncOffline)
                {
                    CurrSyncState = CurrentSyncState.ModSyncError;
                    _errorCode    = errorCode;
                }
            }
            else
            {
                // clear previous errors
                _errorCode = String.Empty;
                // empty response
                if (responseStr.Length == 0)
                {
                    CurrSyncState = CurrentSyncState.Done;
                    return;
                }
                string responseData;
                ModDetailsResponse[] responseDataObj;
                try
                {
                    responseData = Encoding.UTF8.GetString(Convert.FromBase64String(responseStr));
                }
                catch (Exception e)
                {
                    // Failed to parse BASE 64
                    MSLog.Log("Failed to parse BASE 64");
                    MSLog.Log(e.Message);
                    CurrSyncState = CurrentSyncState.ModSyncError;
                    _errorCode    = "151";
                    return;
                }
                try
                {
                    MSLog.Log("Response data BASE 64 set: " + responseData);
                    string[] rows = Regex.Split(responseData.Trim('\"'), "{%}");
                    if (rows.Length == 0)
                    {
                        CurrSyncState = CurrentSyncState.Done;
                        return;
                    }
                    MSLog.Log("Trying to parse data rows");
                    try
                    {
                        foreach (string row in rows)
                        {
                            string rowData = Encoding.UTF8.GetString(Convert.FromBase64String(row));
                            MSLog.Log("Raw row data: " + rowData);
                            ModDetailsResponse rowDataParsed = JsonUtility.FromJson <ModDetailsResponse>(rowData);
                            if (rowDataParsed != null)
                            {
                                MSLog.Log("MF:" + rowDataParsed.MF + " V:" + rowDataParsed.V + " S" +
                                          rowDataParsed.S + " SB" + rowDataParsed.SB);

                                var modData = _relevantMods.FirstOrDefault(x => x.ModDirName.ToUpper().Equals(rowDataParsed.MF.ToUpper()));
                                if (modData == null)
                                {
                                    continue;
                                }
                                modData.RemoteData                = new RemoteModData();
                                modData.IsModSyncMod              = true;
                                modData.RemoteData.IsModSyncMod   = true;
                                modData.RemoteData.Version        = rowDataParsed.V;
                                modData.RemoteData.DownloadUrl    = rowDataParsed.S;
                                modData.RemoteData.IsSaveBreaking = rowDataParsed.SB;
                                modData.ServerLoadedModData       = true;
                            }
                            else
                            {
                                MSLog.Log("Received invalid row, ignoring.");
                            }
                        }
                    }
                    catch (Exception e)
                    {
                        MSLog.Log("Exception:");
                        MSLog.Log(e.Message);
                        CurrSyncState = CurrentSyncState.ModSyncError;
                        _errorCode    = "152";
                    }
                    MSLog.Log("Finished reading json");
                }
                catch (Exception e)
                {
                    // failed to parse JSON
                    MSLog.Log("Failed to parse JSON");
                    MSLog.Log(e.Message);
                    CurrSyncState = CurrentSyncState.ModSyncError;
                    _errorCode    = "153";
                    return;
                }
                //CurrSyncState = CurrentSyncState.RequestStarted;
                CurrSyncState = CurrentSyncState.Done;
            }
        }