Kanishkar J kanishkarj Bangalore https://kanishkarj.github.io/ CSE Undergrad, IIT Indore

startedbrndnmtthws/conky

started time in 2 days

PublicEvent
PublicEvent

issue commenttokio-rs/gsoc

Tokio console

@carllerche yeah definitely :)

carllerche

comment created time in 16 days

startedudacity/self-driving-car

started time in 17 days

startedtryone144/compton

started time in 17 days

issue commenttokio-rs/gsoc

Tokio console

This seems great! Part 2 didn't click me, well it's great that you pointed it out.

Yeah, I guess I could work on the subscriber part. I shall try to understand how a subscriber works so as to define the protobuf schema as soon as possible so that we could work independently.

carllerche

comment created time in 18 days

startedGenymobile/scrcpy

started time in 22 days

startedsimgrid/simgrid

started time in 23 days

pull request commentxi-editor/xi-editor

Fix external state in benchmarking (edit.rs)

Hmm, So you mean to say all the functions use the same offset update ? for eg

offset += 1

would be the offset for all the benchmarks?

kanishkarj

comment created time in a month

PR opened xi-editor/xi-editor

Fix external state in benchmarking (edit.rs)

This is in reference to the discussion in PR #1152. This PR fixes the external state of the iterations in the benchmarks.

+24 -5

0 comment

2 changed files

pr created time in a month

create barnchkanishkarj/xi-editor

branch : bench-fix

created branch time in a month

Pull request review commentxi-editor/xi-editor

Add more benchmarks

 fn benchmark_paste_into_line(b: &mut Bencher) {     }); } +#[bench]+fn benchmark_large_paste_into_line(b: &mut Bencher) {+    let mut text = Rope::from(build_short_lines(1_000_000));+    let insertion = build_short_lines(50_000);+    let mut offset = 25_000;+    b.iter(|| {+        text.edit(offset..=offset, &insertion);+        offset += 150;

Consider it done. :)

kanishkarj

comment created time in a month

fork kanishkarj/ryosuke-gatsby-blog

Static PWA React-powered portfolio and blog built with GatsbyJS

http://whoisryosuke.com

fork in a month

startedkremalicious/portfolio

started time in a month

pull request commenttokio-rs/tokio-trace-nursery

Tokio trace instrumentation example

Done I guess.

kanishkarj

comment created time in a month

push eventkanishkarj/tokio-trace-nursery

kanishkarj

commit sha 720aedc1de0130a95e761266f7d3e870b98941a3

Avoid Panic

view details

push time in a month

Pull request review commenttokio-rs/tokio-trace-nursery

Tokio trace instrumentation example

+/*+This example has been taken and modified from here :+https://raw.githubusercontent.com/tokio-rs/tokio/master/tokio/examples/proxy.rs+*/++extern crate futures;+extern crate tokio;+#[macro_use]+extern crate tokio_trace;+extern crate tokio_trace_fmt;+extern crate tokio_trace_futures;++use tokio_trace::field;+use tokio_trace_futures::Instrument;++use std::env;+use std::io::{self, Read, Write};+use std::net::{IpAddr, Ipv4Addr, Shutdown, SocketAddr};+use std::sync::{Arc, Mutex};++use tokio::io::{copy, shutdown};+use tokio::net::{TcpListener, TcpStream};+use tokio::prelude::*;++fn main() -> Result<(), Box<std::error::Error>> {+    let listen_addr = env::args().nth(1).unwrap_or("127.0.0.1:8081".to_string());+    let listen_addr = listen_addr.parse::<SocketAddr>()?;++    let server_addr = env::args().nth(2).unwrap_or("127.0.0.1:3000".to_string());+    let server_addr = server_addr.parse::<SocketAddr>()?;++    // Create a TCP listener which will listen for incoming connections.+    let socket = TcpListener::bind(&listen_addr)?;+    println!("Listening on: {}", listen_addr);+    println!("Proxying to: {}", server_addr);++    let done = socket+        .incoming()+        .map_err(|e| debug!(msg = "error accepting socket", error = field::display(e)))+        .for_each(move |client| {+            let server = TcpStream::connect(&server_addr);+            let mut client_addr = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 8080);

Take a look now.

kanishkarj

comment created time in a month

push eventkanishkarj/tokio-trace-nursery

kanishkarj

commit sha 2f56c445266875b79d9d10992075dd4e6c0fb2fa

Make client_addr into Option

view details

kanishkarj

commit sha bac4dd4803538353273ff7d7ab282e706626bc4d

Rust FMT

view details

push time in a month

Pull request review commenttokio-rs/tokio-trace-nursery

Tokio trace instrumentation example

+/*+This example has been taken and modified from here :+https://raw.githubusercontent.com/tokio-rs/tokio/master/tokio/examples/proxy.rs+*/++extern crate futures;+extern crate tokio;+#[macro_use]+extern crate tokio_trace;+extern crate tokio_trace_fmt;+extern crate tokio_trace_futures;++use tokio_trace::field;+use tokio_trace_futures::Instrument;++use std::env;+use std::io::{self, Read, Write};+use std::net::{IpAddr, Ipv4Addr, Shutdown, SocketAddr};+use std::sync::{Arc, Mutex};++use tokio::io::{copy, shutdown};+use tokio::net::{TcpListener, TcpStream};+use tokio::prelude::*;++fn main() -> Result<(), Box<std::error::Error>> {+    let listen_addr = env::args().nth(1).unwrap_or("127.0.0.1:8081".to_string());+    let listen_addr = listen_addr.parse::<SocketAddr>()?;++    let server_addr = env::args().nth(2).unwrap_or("127.0.0.1:3000".to_string());+    let server_addr = server_addr.parse::<SocketAddr>()?;++    // Create a TCP listener which will listen for incoming connections.+    let socket = TcpListener::bind(&listen_addr)?;+    println!("Listening on: {}", listen_addr);+    println!("Proxying to: {}", server_addr);++    let done = socket+        .incoming()+        .map_err(|e| debug!(msg = "error accepting socket", error = field::display(e)))+        .for_each(move |client| {+            let server = TcpStream::connect(&server_addr);+            let mut client_addr = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 8080);

Okayy, shall look into it.

kanishkarj

comment created time in a month

pull request commenttokio-rs/tokio-trace-nursery

Tokio trace instrumentation example

How is this ?

kanishkarj

comment created time in a month

push eventkanishkarj/tokio-trace-nursery

kanishkarj

commit sha 8a30aeb2438442dbecced243689ae73117dfdcc2

Updates as per discussion

view details

push time in a month

Pull request review commenttokio-rs/tokio-trace-nursery

Tokio trace instrumentation example

 fn main() -> Result<(), Box<std::error::Error>> {         .map_err(|e| debug!(msg = "error accepting socket", error = field::display(e)))         .for_each(move |client| {             let server = TcpStream::connect(&server_addr);+            let mut client_addr = String::new();             match client.peer_addr() {-                Ok(x) => info!(-                    message = "client connected",-                    client_addr = field::display(x)-                ),+                Ok(x) => {+                    let x = x.to_string();

Done

kanishkarj

comment created time in a month

Pull request review commenttokio-rs/tokio-trace-nursery

Tokio trace instrumentation example

+/*+This example has been taken and modified from here :+https://raw.githubusercontent.com/tokio-rs/tokio/master/tokio/examples/proxy.rs+*/++extern crate futures;+extern crate tokio;+#[macro_use]+extern crate tokio_trace;+extern crate tokio_trace_fmt;+extern crate tokio_trace_futures;++use tokio_trace::field;+use tokio_trace_futures::Instrument;++use std::env;+use std::io::{self, Read, Write};+use std::net::{Shutdown, SocketAddr};+use std::sync::{Arc, Mutex};++use tokio::io::{copy, shutdown};+use tokio::net::{TcpListener, TcpStream};+use tokio::prelude::*;++fn main() -> Result<(), Box<std::error::Error>> {+    let listen_addr = env::args().nth(1).unwrap_or("127.0.0.1:8081".to_string());+    let listen_addr = listen_addr.parse::<SocketAddr>()?;++    let server_addr = env::args().nth(2).unwrap_or("127.0.0.1:3000".to_string());+    let server_addr = server_addr.parse::<SocketAddr>()?;++    // Create a TCP listener which will listen for incoming connections.+    let socket = TcpListener::bind(&listen_addr)?;+    println!("Listening on: {}", listen_addr);+    println!("Proxying to: {}", server_addr);++    let done = socket+        .incoming()+        .map_err(|e| debug!(msg = "error accepting socket", error = field::display(e)))+        .for_each(move |client| {+            let server = TcpStream::connect(&server_addr);+            let mut client_addr = String::new();+            match client.peer_addr() {+                Ok(x) => {+                    let x = x.to_string();+                    client_addr = x;+                    info!(+                        message = "client connected",+                        client_addr = field::display(&client_addr)+                    )+                }+                Err(e) => debug!(+                    message = "could not get client info",+                    error = field::display(e)+                ),+            }++            let amounts = server.and_then(move |server| {+                // Create separate read/write handles for the TCP clients that we're+                // proxying data between. Note that typically you'd use+                // `AsyncRead::split` for this operation, but we want our writer+                // handles to have a custom implementation of `shutdown` which+                // actually calls `TcpStream::shutdown` to ensure that EOF is+                // transmitted properly across the proxied connection.+                //+                // As a result, we wrap up our client/server manually in arcs and+                // use the impls below on our custom `MyTcpStream` type.+                let client_reader = MyTcpStream(Arc::new(Mutex::new(client)));+                let client_writer = client_reader.clone();+                let server_reader = MyTcpStream(Arc::new(Mutex::new(server)));+                let server_writer = server_reader.clone();++                // Copy the data (in parallel) between the client and the server.+                // After the copy is done we indicate to the remote side that we've+                // finished by shutting down the connection.+                let client_to_server = copy(client_reader, server_writer)+                    .and_then(|(n, _, server_writer)| {+                        info!(size = n);+                        shutdown(server_writer).map(move |_| n)+                    })+                    .instrument(span!("client_to_server"));++                let server_to_client = copy(server_reader, client_writer)+                    .and_then(|(n, _, client_writer)| {+                        info!(size = n);+                        shutdown(client_writer).map(move |_| n)+                    })+                    .instrument(span!("server_to_client"));++                client_to_server.join(server_to_client)+            });++            let msg = amounts+                .map(move |(from_client, from_server)| {+                    info!(+                        client_to_server = from_client,+                        server_to_client = from_server+                    );+                })+                .map_err(|e| {+                    // Don't panic. Maybe the client just disconnected too soon.+                    debug!(error = field::display(e));+                })+                .instrument(span!(+                    "transfer",+                    client_address = field::debug(&client_addr),+                    server_address = field::debug(&server_addr.to_string())

Done

kanishkarj

comment created time in a month

Pull request review commenttokio-rs/tokio-trace-nursery

Tokio trace instrumentation example

+/*+This example has been taken and modified from here :+https://raw.githubusercontent.com/tokio-rs/tokio/master/tokio/examples/proxy.rs+*/++extern crate futures;+extern crate tokio;+#[macro_use]+extern crate tokio_trace;+extern crate tokio_trace_fmt;+extern crate tokio_trace_futures;++use tokio_trace::field;+use tokio_trace_futures::Instrument;++use std::env;+use std::io::{self, Read, Write};+use std::net::{Shutdown, SocketAddr};+use std::sync::{Arc, Mutex};++use tokio::io::{copy, shutdown};+use tokio::net::{TcpListener, TcpStream};+use tokio::prelude::*;++fn main() -> Result<(), Box<std::error::Error>> {+    let listen_addr = env::args().nth(1).unwrap_or("127.0.0.1:8081".to_string());+    let listen_addr = listen_addr.parse::<SocketAddr>()?;++    let server_addr = env::args().nth(2).unwrap_or("127.0.0.1:3000".to_string());+    let server_addr = server_addr.parse::<SocketAddr>()?;++    // Create a TCP listener which will listen for incoming connections.+    let socket = TcpListener::bind(&listen_addr)?;+    println!("Listening on: {}", listen_addr);+    println!("Proxying to: {}", server_addr);++    let done = socket+        .incoming()+        .map_err(|e| debug!(msg = "error accepting socket", error = field::display(e)))+        .for_each(move |client| {+            let server = TcpStream::connect(&server_addr);+            let mut client_addr = String::new();+            match client.peer_addr() {+                Ok(x) => {+                    let x = x.to_string();+                    client_addr = x;+                    info!(+                        message = "client connected",+                        client_addr = field::display(&client_addr)+                    )+                }+                Err(e) => debug!(+                    message = "could not get client info",+                    error = field::display(e)+                ),+            }++            let amounts = server.and_then(move |server| {+                // Create separate read/write handles for the TCP clients that we're+                // proxying data between. Note that typically you'd use+                // `AsyncRead::split` for this operation, but we want our writer+                // handles to have a custom implementation of `shutdown` which+                // actually calls `TcpStream::shutdown` to ensure that EOF is+                // transmitted properly across the proxied connection.+                //+                // As a result, we wrap up our client/server manually in arcs and+                // use the impls below on our custom `MyTcpStream` type.+                let client_reader = MyTcpStream(Arc::new(Mutex::new(client)));+                let client_writer = client_reader.clone();+                let server_reader = MyTcpStream(Arc::new(Mutex::new(server)));+                let server_writer = server_reader.clone();++                // Copy the data (in parallel) between the client and the server.+                // After the copy is done we indicate to the remote side that we've+                // finished by shutting down the connection.+                let client_to_server = copy(client_reader, server_writer)+                    .and_then(|(n, _, server_writer)| {+                        info!(size = n);+                        shutdown(server_writer).map(move |_| n)+                    })+                    .instrument(span!("client_to_server"));++                let server_to_client = copy(server_reader, client_writer)+                    .and_then(|(n, _, client_writer)| {+                        info!(size = n);+                        shutdown(client_writer).map(move |_| n)+                    })+                    .instrument(span!("server_to_client"));++                client_to_server.join(server_to_client)+            });++            let msg = amounts+                .map(move |(from_client, from_server)| {+                    info!(+                        client_to_server = from_client,+                        server_to_client = from_server+                    );+                })+                .map_err(|e| {+                    // Don't panic. Maybe the client just disconnected too soon.+                    debug!(error = field::display(e));+                })+                .instrument(span!(+                    "transfer",+                    client_address = field::debug(&client_addr),+                    server_address = field::debug(&server_addr.to_string())+                ));++            tokio::spawn(msg);++            Ok(())+        })+        .instrument(span!("proxy", listen_addr = field::debug(&listen_addr)));

Okay.. I think debug is more descriptive.

kanishkarj

comment created time in a month

Pull request review commenttokio-rs/tokio-trace-nursery

Tokio trace instrumentation example

+/*+This example has been taken and modified from here :+https://raw.githubusercontent.com/tokio-rs/tokio/master/tokio/examples/proxy.rs+*/++extern crate futures;+extern crate tokio;+#[macro_use]+extern crate tokio_trace;+extern crate tokio_trace_fmt;+extern crate tokio_trace_futures;++use tokio_trace::field;+use tokio_trace_futures::Instrument;++use std::env;+use std::io::{self, Read, Write};+use std::net::{Shutdown, SocketAddr};+use std::sync::{Arc, Mutex};++use tokio::io::{copy, shutdown};+use tokio::net::{TcpListener, TcpStream};+use tokio::prelude::*;++fn main() -> Result<(), Box<std::error::Error>> {+    let listen_addr = env::args().nth(1).unwrap_or("127.0.0.1:8081".to_string());+    let listen_addr = listen_addr.parse::<SocketAddr>()?;++    let server_addr = env::args().nth(2).unwrap_or("127.0.0.1:3000".to_string());+    let server_addr = server_addr.parse::<SocketAddr>()?;++    // Create a TCP listener which will listen for incoming connections.+    let socket = TcpListener::bind(&listen_addr)?;+    println!("Listening on: {}", listen_addr);+    println!("Proxying to: {}", server_addr);++    let done = socket+        .incoming()+        .map_err(|e| debug!(msg = "error accepting socket", error = field::display(e)))+        .for_each(move |client| {+            let server = TcpStream::connect(&server_addr);+            match client.peer_addr() {+                Ok(x) => info!(

Ah got it.

kanishkarj

comment created time in a month

Pull request review commenttokio-rs/tokio-trace-nursery

Tokio trace instrumentation example

+/*+This example has been taken and modified from here :+https://raw.githubusercontent.com/tokio-rs/tokio/master/tokio/examples/proxy.rs+*/++extern crate futures;+extern crate tokio;+#[macro_use]+extern crate tokio_trace;+extern crate tokio_trace_fmt;+extern crate tokio_trace_futures;++use tokio_trace::field;+use tokio_trace_futures::Instrument;++use std::env;+use std::io::{self, Read, Write};+use std::net::{Shutdown, SocketAddr};+use std::sync::{Arc, Mutex};++use tokio::io::{copy, shutdown};+use tokio::net::{TcpListener, TcpStream};+use tokio::prelude::*;++fn main() -> Result<(), Box<std::error::Error>> {+    let listen_addr = env::args().nth(1).unwrap_or("127.0.0.1:8081".to_string());+    let listen_addr = listen_addr.parse::<SocketAddr>()?;++    let server_addr = env::args().nth(2).unwrap_or("127.0.0.1:3000".to_string());+    let server_addr = server_addr.parse::<SocketAddr>()?;++    // Create a TCP listener which will listen for incoming connections.+    let socket = TcpListener::bind(&listen_addr)?;+    println!("Listening on: {}", listen_addr);+    println!("Proxying to: {}", server_addr);++    let done = socket+        .incoming()+        .map_err(|e| debug!(msg = "error accepting socket", error = field::display(e)))+        .for_each(move |client| {+            let server = TcpStream::connect(&server_addr);+            let mut client_addr = String::new();+            match client.peer_addr() {+                Ok(x) => {+                    let x = x.to_string();+                    client_addr = x;+                    info!(+                        message = "client connected",+                        client_addr = field::display(&client_addr)+                    )+                }+                Err(e) => debug!(+                    message = "could not get client info",+                    error = field::display(e)+                ),+            }++            let amounts = server.and_then(move |server| {+                // Create separate read/write handles for the TCP clients that we're+                // proxying data between. Note that typically you'd use+                // `AsyncRead::split` for this operation, but we want our writer+                // handles to have a custom implementation of `shutdown` which+                // actually calls `TcpStream::shutdown` to ensure that EOF is+                // transmitted properly across the proxied connection.+                //+                // As a result, we wrap up our client/server manually in arcs and+                // use the impls below on our custom `MyTcpStream` type.+                let client_reader = MyTcpStream(Arc::new(Mutex::new(client)));+                let client_writer = client_reader.clone();+                let server_reader = MyTcpStream(Arc::new(Mutex::new(server)));+                let server_writer = server_reader.clone();++                // Copy the data (in parallel) between the client and the server.+                // After the copy is done we indicate to the remote side that we've+                // finished by shutting down the connection.+                let client_to_server = copy(client_reader, server_writer)+                    .and_then(|(n, _, server_writer)| {+                        info!(size = n);+                        shutdown(server_writer).map(move |_| n)+                    })+                    .instrument(span!("client_to_server"));++                let server_to_client = copy(server_reader, client_writer)+                    .and_then(|(n, _, client_writer)| {+                        info!(size = n);+                        shutdown(client_writer).map(move |_| n)+                    })+                    .instrument(span!("server_to_client"));++                client_to_server.join(server_to_client)+            });++            let msg = amounts+                .map(move |(from_client, from_server)| {+                    info!(

Done

kanishkarj

comment created time in a month

push eventkanishkarj/xi-editor

kanishkarj

commit sha a54311305f585cf656d0d6dcb7a614ce9a0433d2

Rust FMT

view details

push time in a month

PR opened xi-editor/xi-editor

Add more benchmarks

Added a few more benchmarks.

+27 -0

0 comment

2 changed files

pr created time in a month

create barnchkanishkarj/xi-editor

branch : bench

created branch time in a month

Pull request review commenttokio-rs/tokio-trace-nursery

Tokio trace instrumentation example

+/*+This example has been taken and modified from here :+https://raw.githubusercontent.com/tokio-rs/tokio/master/tokio/examples/proxy.rs+*/++extern crate futures;+extern crate tokio;+#[macro_use]+extern crate tokio_trace;+extern crate tokio_trace_fmt;+extern crate tokio_trace_futures;++use tokio_trace::field;+use tokio_trace_futures::Instrument;++use std::env;+use std::io::{self, Read, Write};+use std::net::{Shutdown, SocketAddr};+use std::sync::{Arc, Mutex};++use tokio::io::{copy, shutdown};+use tokio::net::{TcpListener, TcpStream};+use tokio::prelude::*;++fn main() -> Result<(), Box<std::error::Error>> {+    let listen_addr = env::args().nth(1).unwrap_or("127.0.0.1:8081".to_string());+    let listen_addr = listen_addr.parse::<SocketAddr>()?;++    let server_addr = env::args().nth(2).unwrap_or("127.0.0.1:3000".to_string());+    let server_addr = server_addr.parse::<SocketAddr>()?;++    // Create a TCP listener which will listen for incoming connections.+    let socket = TcpListener::bind(&listen_addr)?;+    println!("Listening on: {}", listen_addr);+    println!("Proxying to: {}", server_addr);++    let done = socket+        .incoming()+        .map_err(|e| debug!(msg = "error accepting socket", error = field::display(e)))+        .for_each(move |client| {+            let server = TcpStream::connect(&server_addr);+            match client.peer_addr() {+                Ok(x) => info!(

shouldn't that be printed? also another thing to notice is that the outer most scope prints proxy_server despite being instrumented as proxy.

kanishkarj

comment created time in a month

push eventkanishkarj/tokio-trace-nursery

kanishkarj

commit sha ebcda2821d7b0f49dcce8bca68aeef40566ee722

Rust FMT

view details

push time in a month

push eventkanishkarj/tokio-trace-nursery

kanishkarj

commit sha 0e207e43c30a005fa582010fc1d274a14bf3244c

Detailed Diagnosis

view details

push time in a month

Pull request review commenttokio-rs/tokio-trace-nursery

Tokio trace instrumentation example

+/*+This example has been taken and modified from here : +https://raw.githubusercontent.com/tokio-rs/tokio/master/tokio/examples/proxy.rs+*/++#![deny(warnings)]++extern crate futures;+extern crate tokio;+#[macro_use]+extern crate tokio_trace;+extern crate tokio_trace_fmt;+extern crate tokio_trace_futures;++use tokio_trace_futures::Instrument;++use std::env;+use std::io::{self, Read, Write};+use std::net::{Shutdown, SocketAddr};+use std::sync::{Arc, Mutex};++use tokio::io::{copy, shutdown};+use tokio::net::{TcpListener, TcpStream};+use tokio::prelude::*;++fn main() -> Result<(), Box<std::error::Error>> {+    let listen_addr = env::args().nth(1).unwrap_or("127.0.0.1:8081".to_string());+    let listen_addr = listen_addr.parse::<SocketAddr>()?;++    let server_addr = env::args().nth(2).unwrap_or("127.0.0.1:3000".to_string());+    let server_addr = server_addr.parse::<SocketAddr>()?;++    // Create a TCP listener which will listen for incoming connections.+    let socket = TcpListener::bind(&listen_addr)?;+    println!("Listening on: {}", listen_addr);+    println!("Proxying to: {}", server_addr);++    let done = socket+        .incoming()+        .map_err(|e| {+            debug!("error accepting socket; error = {:?}", e)+        })+        .for_each(move |client| {+            let server = TcpStream::connect(&server_addr);+            match client.peer_addr() {+                Ok(x) => info!("client connected {}", x), +                Err(e) => debug!("error, could not get client info: {}", e)+            }+            +            let amounts = server.and_then(move |server| {+                // Create separate read/write handles for the TCP clients that we're+                // proxying data between. Note that typically you'd use+                // `AsyncRead::split` for this operation, but we want our writer+                // handles to have a custom implementation of `shutdown` which+                // actually calls `TcpStream::shutdown` to ensure that EOF is+                // transmitted properly across the proxied connection.+                //+                // As a result, we wrap up our client/server manually in arcs and+                // use the impls below on our custom `MyTcpStream` type.+                let client_reader = MyTcpStream(Arc::new(Mutex::new(client)));+                let client_writer = client_reader.clone();+                let server_reader = MyTcpStream(Arc::new(Mutex::new(server)));+                let server_writer = server_reader.clone();++                // Copy the data (in parallel) between the client and the server.+                // After the copy is done we indicate to the remote side that we've+                // finished by shutting down the connection.+                let client_to_server = copy(client_reader, server_writer)+                    .and_then(|(n, _, server_writer)| {+                        info!(size = n);+                        shutdown(server_writer).map(move |_| n)+                    }).instrument(span!(" client_to_server"));++                let server_to_client = copy(server_reader, client_writer)+                    .and_then(|(n, _, client_writer)| {+                        info!(size = n);+                        shutdown(client_writer).map(move |_| n)+                    }).instrument(span!(" server_to_client"));++                client_to_server.join(server_to_client)+            });++            let msg = amounts+                .map(move |(from_client, from_server)| {+                    info!(+                        "client wrote {} bytes and received {} bytes",+                        from_client, from_server+                    );+                })+                .map_err(|e| {+                    // Don't panic. Maybe the client just disconnected too soon.+                    debug!("error: {}", e);+                }).instrument(span!(" transfer_complete"));

Done

kanishkarj

comment created time in a month

Pull request review commenttokio-rs/tokio-trace-nursery

Tokio trace instrumentation example

+/*+This example has been taken and modified from here : +https://raw.githubusercontent.com/tokio-rs/tokio/master/tokio/examples/proxy.rs+*/++#![deny(warnings)]++extern crate futures;+extern crate tokio;+#[macro_use]+extern crate tokio_trace;+extern crate tokio_trace_fmt;+extern crate tokio_trace_futures;++use tokio_trace_futures::Instrument;++use std::env;+use std::io::{self, Read, Write};+use std::net::{Shutdown, SocketAddr};+use std::sync::{Arc, Mutex};++use tokio::io::{copy, shutdown};+use tokio::net::{TcpListener, TcpStream};+use tokio::prelude::*;++fn main() -> Result<(), Box<std::error::Error>> {+    let listen_addr = env::args().nth(1).unwrap_or("127.0.0.1:8081".to_string());+    let listen_addr = listen_addr.parse::<SocketAddr>()?;++    let server_addr = env::args().nth(2).unwrap_or("127.0.0.1:3000".to_string());+    let server_addr = server_addr.parse::<SocketAddr>()?;++    // Create a TCP listener which will listen for incoming connections.+    let socket = TcpListener::bind(&listen_addr)?;+    println!("Listening on: {}", listen_addr);+    println!("Proxying to: {}", server_addr);++    let done = socket+        .incoming()+        .map_err(|e| {+            debug!("error accepting socket; error = {:?}", e)+        })+        .for_each(move |client| {+            let server = TcpStream::connect(&server_addr);+            match client.peer_addr() {+                Ok(x) => info!("client connected {}", x), +                Err(e) => debug!("error, could not get client info: {}", e)+            }+            +            let amounts = server.and_then(move |server| {+                // Create separate read/write handles for the TCP clients that we're+                // proxying data between. Note that typically you'd use+                // `AsyncRead::split` for this operation, but we want our writer+                // handles to have a custom implementation of `shutdown` which+                // actually calls `TcpStream::shutdown` to ensure that EOF is+                // transmitted properly across the proxied connection.+                //+                // As a result, we wrap up our client/server manually in arcs and+                // use the impls below on our custom `MyTcpStream` type.+                let client_reader = MyTcpStream(Arc::new(Mutex::new(client)));+                let client_writer = client_reader.clone();+                let server_reader = MyTcpStream(Arc::new(Mutex::new(server)));+                let server_writer = server_reader.clone();++                // Copy the data (in parallel) between the client and the server.+                // After the copy is done we indicate to the remote side that we've+                // finished by shutting down the connection.+                let client_to_server = copy(client_reader, server_writer)+                    .and_then(|(n, _, server_writer)| {+                        info!(size = n);+                        shutdown(server_writer).map(move |_| n)+                    }).instrument(span!(" client_to_server"));++                let server_to_client = copy(server_reader, client_writer)+                    .and_then(|(n, _, client_writer)| {+                        info!(size = n);+                        shutdown(client_writer).map(move |_| n)+                    }).instrument(span!(" server_to_client"));

Done

kanishkarj

comment created time in a month

Pull request review commenttokio-rs/tokio-trace-nursery

Tokio trace instrumentation example

+/*+This example has been taken and modified from here : +https://raw.githubusercontent.com/tokio-rs/tokio/master/tokio/examples/proxy.rs+*/++#![deny(warnings)]++extern crate futures;+extern crate tokio;+#[macro_use]+extern crate tokio_trace;+extern crate tokio_trace_fmt;+extern crate tokio_trace_futures;++use tokio_trace_futures::Instrument;++use std::env;+use std::io::{self, Read, Write};+use std::net::{Shutdown, SocketAddr};+use std::sync::{Arc, Mutex};++use tokio::io::{copy, shutdown};+use tokio::net::{TcpListener, TcpStream};+use tokio::prelude::*;++fn main() -> Result<(), Box<std::error::Error>> {+    let listen_addr = env::args().nth(1).unwrap_or("127.0.0.1:8081".to_string());+    let listen_addr = listen_addr.parse::<SocketAddr>()?;++    let server_addr = env::args().nth(2).unwrap_or("127.0.0.1:3000".to_string());+    let server_addr = server_addr.parse::<SocketAddr>()?;++    // Create a TCP listener which will listen for incoming connections.+    let socket = TcpListener::bind(&listen_addr)?;+    println!("Listening on: {}", listen_addr);+    println!("Proxying to: {}", server_addr);++    let done = socket+        .incoming()+        .map_err(|e| {+            debug!("error accepting socket; error = {:?}", e)+        })+        .for_each(move |client| {+            let server = TcpStream::connect(&server_addr);+            match client.peer_addr() {+                Ok(x) => info!("client connected {}", x), 

Done!

kanishkarj

comment created time in a month

Pull request review commenttokio-rs/tokio-trace-nursery

Tokio trace instrumentation example

+/*+This example has been taken and modified from here : +https://raw.githubusercontent.com/tokio-rs/tokio/master/tokio/examples/proxy.rs+*/++#![deny(warnings)]++extern crate futures;+extern crate tokio;+#[macro_use]+extern crate tokio_trace;+extern crate tokio_trace_fmt;+extern crate tokio_trace_futures;++use tokio_trace_futures::Instrument;++use std::env;+use std::io::{self, Read, Write};+use std::net::{Shutdown, SocketAddr};+use std::sync::{Arc, Mutex};++use tokio::io::{copy, shutdown};+use tokio::net::{TcpListener, TcpStream};+use tokio::prelude::*;++fn main() -> Result<(), Box<std::error::Error>> {+    let listen_addr = env::args().nth(1).unwrap_or("127.0.0.1:8081".to_string());+    let listen_addr = listen_addr.parse::<SocketAddr>()?;++    let server_addr = env::args().nth(2).unwrap_or("127.0.0.1:3000".to_string());+    let server_addr = server_addr.parse::<SocketAddr>()?;++    // Create a TCP listener which will listen for incoming connections.+    let socket = TcpListener::bind(&listen_addr)?;+    println!("Listening on: {}", listen_addr);+    println!("Proxying to: {}", server_addr);++    let done = socket+        .incoming()+        .map_err(|e| {+            debug!("error accepting socket; error = {:?}", e)+        })+        .for_each(move |client| {+            let server = TcpStream::connect(&server_addr);+            match client.peer_addr() {+                Ok(x) => info!("client connected {}", x), +                Err(e) => debug!("error, could not get client info: {}", e)+            }+            +            let amounts = server.and_then(move |server| {+                // Create separate read/write handles for the TCP clients that we're+                // proxying data between. Note that typically you'd use+                // `AsyncRead::split` for this operation, but we want our writer+                // handles to have a custom implementation of `shutdown` which+                // actually calls `TcpStream::shutdown` to ensure that EOF is+                // transmitted properly across the proxied connection.+                //+                // As a result, we wrap up our client/server manually in arcs and+                // use the impls below on our custom `MyTcpStream` type.+                let client_reader = MyTcpStream(Arc::new(Mutex::new(client)));+                let client_writer = client_reader.clone();+                let server_reader = MyTcpStream(Arc::new(Mutex::new(server)));+                let server_writer = server_reader.clone();++                // Copy the data (in parallel) between the client and the server.+                // After the copy is done we indicate to the remote side that we've+                // finished by shutting down the connection.+                let client_to_server = copy(client_reader, server_writer)+                    .and_then(|(n, _, server_writer)| {+                        info!(size = n);+                        shutdown(server_writer).map(move |_| n)+                    }).instrument(span!(" client_to_server"));++                let server_to_client = copy(server_reader, client_writer)+                    .and_then(|(n, _, client_writer)| {+                        info!(size = n);+                        shutdown(client_writer).map(move |_| n)+                    }).instrument(span!(" server_to_client"));

Done!

kanishkarj

comment created time in a month

Pull request review commenttokio-rs/tokio-trace-nursery

Tokio trace instrumentation example

+/*+This example has been taken and modified from here :+https://raw.githubusercontent.com/tokio-rs/tokio/master/tokio/examples/proxy.rs+*/++extern crate futures;+extern crate tokio;+#[macro_use]+extern crate tokio_trace;+extern crate tokio_trace_fmt;+extern crate tokio_trace_futures;++use tokio_trace::field;+use tokio_trace_futures::Instrument;++use std::env;+use std::io::{self, Read, Write};+use std::net::{Shutdown, SocketAddr};+use std::sync::{Arc, Mutex};++use tokio::io::{copy, shutdown};+use tokio::net::{TcpListener, TcpStream};+use tokio::prelude::*;++fn main() -> Result<(), Box<std::error::Error>> {+    let listen_addr = env::args().nth(1).unwrap_or("127.0.0.1:8081".to_string());+    let listen_addr = listen_addr.parse::<SocketAddr>()?;++    let server_addr = env::args().nth(2).unwrap_or("127.0.0.1:3000".to_string());+    let server_addr = server_addr.parse::<SocketAddr>()?;++    // Create a TCP listener which will listen for incoming connections.+    let socket = TcpListener::bind(&listen_addr)?;+    println!("Listening on: {}", listen_addr);+    println!("Proxying to: {}", server_addr);++    let done = socket+        .incoming()+        .map_err(|e| debug!(msg = "error accepting socket", error = field::display(e)))+        .for_each(move |client| {+            let server = TcpStream::connect(&server_addr);+            match client.peer_addr() {+                Ok(x) => info!(

I mean the Ok(x) => info!(

kanishkarj

comment created time in a month

Pull request review commenttokio-rs/tokio-trace-nursery

Tokio trace instrumentation example

+/*+This example has been taken and modified from here :+https://raw.githubusercontent.com/tokio-rs/tokio/master/tokio/examples/proxy.rs+*/++extern crate futures;+extern crate tokio;+#[macro_use]+extern crate tokio_trace;+extern crate tokio_trace_fmt;+extern crate tokio_trace_futures;++use tokio_trace::field;+use tokio_trace_futures::Instrument;++use std::env;+use std::io::{self, Read, Write};+use std::net::{Shutdown, SocketAddr};+use std::sync::{Arc, Mutex};++use tokio::io::{copy, shutdown};+use tokio::net::{TcpListener, TcpStream};+use tokio::prelude::*;++fn main() -> Result<(), Box<std::error::Error>> {+    let listen_addr = env::args().nth(1).unwrap_or("127.0.0.1:8081".to_string());+    let listen_addr = listen_addr.parse::<SocketAddr>()?;++    let server_addr = env::args().nth(2).unwrap_or("127.0.0.1:3000".to_string());+    let server_addr = server_addr.parse::<SocketAddr>()?;++    // Create a TCP listener which will listen for incoming connections.+    let socket = TcpListener::bind(&listen_addr)?;+    println!("Listening on: {}", listen_addr);+    println!("Proxying to: {}", server_addr);++    let done = socket+        .incoming()+        .map_err(|e| debug!(msg = "error accepting socket", error = field::display(e)))+        .for_each(move |client| {+            let server = TcpStream::connect(&server_addr);+            match client.peer_addr() {+                Ok(x) => info!(

Ah, that's because no events are actually being recorded inside that span. If this wasn't the case (i.e. if we had enabled events emitted by tokio or another dependency, or if we added events in that span) we would see it in the logs as well.

How about this ?

kanishkarj

comment created time in a month

Pull request review commenttokio-rs/tokio-trace-nursery

Tokio trace instrumentation example

+/*+This example has been taken and modified from here : +https://raw.githubusercontent.com/tokio-rs/tokio/master/tokio/examples/proxy.rs+*/++#![deny(warnings)]++extern crate futures;+extern crate tokio;+#[macro_use]+extern crate tokio_trace;+extern crate tokio_trace_fmt;+extern crate tokio_trace_futures;++use tokio_trace_futures::Instrument;++use std::env;+use std::io::{self, Read, Write};+use std::net::{Shutdown, SocketAddr};+use std::sync::{Arc, Mutex};++use tokio::io::{copy, shutdown};+use tokio::net::{TcpListener, TcpStream};+use tokio::prelude::*;++fn main() -> Result<(), Box<std::error::Error>> {+    let listen_addr = env::args().nth(1).unwrap_or("127.0.0.1:8081".to_string());+    let listen_addr = listen_addr.parse::<SocketAddr>()?;++    let server_addr = env::args().nth(2).unwrap_or("127.0.0.1:3000".to_string());+    let server_addr = server_addr.parse::<SocketAddr>()?;++    // Create a TCP listener which will listen for incoming connections.+    let socket = TcpListener::bind(&listen_addr)?;+    println!("Listening on: {}", listen_addr);+    println!("Proxying to: {}", server_addr);++    let done = socket+        .incoming()+        .map_err(|e| {+            debug!("error accepting socket; error = {:?}", e)+        })+        .for_each(move |client| {+            let server = TcpStream::connect(&server_addr);+            match client.peer_addr() {+                Ok(x) => info!("client connected {}", x), +                Err(e) => debug!("error, could not get client info: {}", e)+            }+            +            let amounts = server.and_then(move |server| {+                // Create separate read/write handles for the TCP clients that we're+                // proxying data between. Note that typically you'd use+                // `AsyncRead::split` for this operation, but we want our writer+                // handles to have a custom implementation of `shutdown` which+                // actually calls `TcpStream::shutdown` to ensure that EOF is+                // transmitted properly across the proxied connection.+                //+                // As a result, we wrap up our client/server manually in arcs and+                // use the impls below on our custom `MyTcpStream` type.+                let client_reader = MyTcpStream(Arc::new(Mutex::new(client)));+                let client_writer = client_reader.clone();+                let server_reader = MyTcpStream(Arc::new(Mutex::new(server)));+                let server_writer = server_reader.clone();++                // Copy the data (in parallel) between the client and the server.+                // After the copy is done we indicate to the remote side that we've+                // finished by shutting down the connection.+                let client_to_server = copy(client_reader, server_writer)+                    .and_then(|(n, _, server_writer)| {+                        info!(size = n);+                        shutdown(server_writer).map(move |_| n)+                    }).instrument(span!(" client_to_server"));

Done

kanishkarj

comment created time in a month

pull request commenttokio-rs/tokio-trace-nursery

Tokio trace instrumentation example

I was not able to resolve the warnings as they were in other crates, or not where I could really fix it. I could look into fixing other warnings but I guess it should be another PR. But, is every other thing okay, @hawkw ?

kanishkarj

comment created time in a month

push eventkanishkarj/tokio-trace-nursery

kanishkarj

commit sha d39177592ba8e0a29feb46065b90f836d23ff3bb

Enable warnings

view details

push time in a month

pull request commenttokio-rs/tokio-trace-nursery

Tokio trace instrumentation example

Okay, I shall look into it. Thanks a lot though!

kanishkarj

comment created time in a month

pull request commenttokio-rs/tokio-trace-nursery

Tokio trace instrumentation example

why is my build failing with rust-1.26.0 ? And what can I do to fix it?

kanishkarj

comment created time in a month

push eventkanishkarj/tokio-trace-nursery

kanishkarj

commit sha d99da2dc09983f079ddbc10e6ccde8ed314f7a80

Rust FMT

view details

push time in a month

pull request commenttokio-rs/tokio-trace-nursery

Tokio trace instrumentation example

I have made all the changes as discussed above.

kanishkarj

comment created time in a month

push eventkanishkarj/tokio-trace-nursery

kanishkarj

commit sha cc7882b44c24bace788de92b2166b8dea8de4c16

Get more diagnostics

view details

push time in a month

Pull request review commenttokio-rs/tokio-trace-nursery

Tokio trace instrumentation example

+/*+This example has been taken and modified from here : +https://raw.githubusercontent.com/tokio-rs/tokio/master/tokio/examples/proxy.rs+*/++#![deny(warnings)]++extern crate futures;+extern crate tokio;+#[macro_use]+extern crate tokio_trace;+extern crate tokio_trace_fmt;+extern crate tokio_trace_futures;++use tokio_trace_futures::Instrument;++use std::env;+use std::io::{self, Read, Write};+use std::net::{Shutdown, SocketAddr};+use std::sync::{Arc, Mutex};++use tokio::io::{copy, shutdown};+use tokio::net::{TcpListener, TcpStream};+use tokio::prelude::*;++fn main() -> Result<(), Box<std::error::Error>> {+    let listen_addr = env::args().nth(1).unwrap_or("127.0.0.1:8081".to_string());+    let listen_addr = listen_addr.parse::<SocketAddr>()?;++    let server_addr = env::args().nth(2).unwrap_or("127.0.0.1:3000".to_string());+    let server_addr = server_addr.parse::<SocketAddr>()?;++    // Create a TCP listener which will listen for incoming connections.+    let socket = TcpListener::bind(&listen_addr)?;+    println!("Listening on: {}", listen_addr);+    println!("Proxying to: {}", server_addr);++    let done = socket+        .incoming()+        .map_err(|e| {+            debug!("error accepting socket; error = {:?}", e)+        })+        .for_each(move |client| {+            let server = TcpStream::connect(&server_addr);+            match client.peer_addr() {+                Ok(x) => info!("client connected {}", x), +                Err(e) => debug!("error, could not get client info: {}", e)+            }+            +            let amounts = server.and_then(move |server| {+                // Create separate read/write handles for the TCP clients that we're+                // proxying data between. Note that typically you'd use+                // `AsyncRead::split` for this operation, but we want our writer+                // handles to have a custom implementation of `shutdown` which+                // actually calls `TcpStream::shutdown` to ensure that EOF is+                // transmitted properly across the proxied connection.+                //+                // As a result, we wrap up our client/server manually in arcs and+                // use the impls below on our custom `MyTcpStream` type.+                let client_reader = MyTcpStream(Arc::new(Mutex::new(client)));+                let client_writer = client_reader.clone();+                let server_reader = MyTcpStream(Arc::new(Mutex::new(server)));+                let server_writer = server_reader.clone();++                // Copy the data (in parallel) between the client and the server.+                // After the copy is done we indicate to the remote side that we've+                // finished by shutting down the connection.+                let client_to_server = copy(client_reader, server_writer)+                    .and_then(|(n, _, server_writer)| {+                        info!(size = n);+                        shutdown(server_writer).map(move |_| n)+                    }).instrument(span!(" client_to_server"));++                let server_to_client = copy(server_reader, client_writer)+                    .and_then(|(n, _, client_writer)| {+                        info!(size = n);+                        shutdown(client_writer).map(move |_| n)+                    }).instrument(span!(" server_to_client"));++                client_to_server.join(server_to_client)+            });++            let msg = amounts+                .map(move |(from_client, from_server)| {+                    info!(+                        "client wrote {} bytes and received {} bytes",+                        from_client, from_server+                    );+                })+                .map_err(|e| {+                    // Don't panic. Maybe the client just disconnected too soon.+                    debug!("error: {}", e);+                }).instrument(span!(" transfer_complete"));++            tokio::spawn(msg);++            Ok(())+        });

I didn't instrument that because for some reason that was not being printed out. This is the output after I made the changes :

 INFO proxy_server: client connected client_addr=127.0.0.1:45762
 INFO transfer:client_to_server: proxy_server: size=149
 INFO transfer:server_to_client: proxy_server: size=138
 INFO transfer: proxy_server: client_to_server=149 server_to_client=138
kanishkarj

comment created time in a month

pull request commenttokio-rs/tokio-trace-nursery

Tokio trace instrumentation example

Great I shall look into it.

kanishkarj

comment created time in a month

startedtokio-rs/gsoc

started time in a month

startedtokio-rs/gsoc

started time in a month

PR opened tokio-rs/tokio-trace-nursery

Tokio trace instrumentation example

This is an example of demonstrating tokio-trace instrumentation. I have used the proxy server implementation in the Tokio crate examples.

+137 -0

0 comment

1 changed file

pr created time in a month

push eventkanishkarj/tokio-trace-nursery

kanishkarj

commit sha 78277a4d748bc53b29b4b33d78057a3251d3850b

Added the proxy server example from `tokio-rs/tokio`

view details

kanishkarj

commit sha 3a53917bc66c465024d26110ea352f80d9b6bffd

instrumented using tokio trace

view details

push time in a month

fork kanishkarj/tokio-trace-nursery

Less-stable utility crates for `tokio-trace`

fork in a month

startedteamprevue/PreVue

started time in a month

startedAmagnum/Music-notes-detection

started time in a month

PublicEvent

push eventDaemonLab/euristica_posters

kanishkarj

commit sha 28346118ae78fd760160c6ddc74ff1a6f7d13baa

Replaced the Hackathon poster with new one.

view details

push time in a month

startedjohanmalm/jgmenu

started time in a month

startedwhoisryosuke/ryosuke-gatsby-blog

started time in a month

startedbchiang7/v4

started time in a month

push eventpclubiiti/Euristica2018

kanishkarj

commit sha 441c3ee8c37479f91b47959935b6a9beb86c6db6

Update the logo

view details

push time in a month

startedexperiencor/keras-yolo2

started time in a month

starteddonnemartin/system-design-primer

started time in a month

startedBayesWitnesses/m2cgen

started time in 2 months

startedAareon/Codingg

started time in 2 months

startedPistonDevelopers/dyon

started time in 2 months

startedcmr/lets-build-a-compiler

started time in 2 months

startedagalwood/Motrix

started time in 2 months

startedgpujs/gpu.js

started time in 2 months

startedantoyo/relm

started time in 2 months

startedavr-rust/rust

started time in 2 months

startedxanderchf/faster-rcnn-KITTI-BDD100k

started time in 2 months

pull request commentxi-editor/xi-editor

Add Page Up and Page Down

I need some help with getting the cursor to not move. I tried messing around with selections and carets, but couldn't get much out of it.

kanishkarj

comment created time in 2 months

push eventkanishkarj/xi-editor

kanishkarj

commit sha 3d4738f3806510acbce9693e83a6f9112893a503

Page moves down. But cursor also moves with it.

view details

push time in 2 months

push eventkanishkarj/xi-editor

kanishkarj

commit sha 7f041ed427c19e8a45d404994397a2a0381268bd

Test self.set_scroll for page up/down

view details

push time in 2 months

pull request commentxi-editor/xi-editor

Add Page Up and Page Down

Yes, so shall I go with implementing this properly ? Like without changing the selection.

kanishkarj

comment created time in 2 months

pull request commentxi-editor/xi-editor

Add Page Up and Page Down

But doesn't xi-editor already implement that? PageUp and PageDown are working on the GXI front-end. That's why I assumed I was supposed to implement ScrollPageUp/ScrollPageDown. I have attached a clip of what happens in GXI on PageUp and PageDown, take a look at it.

peek 2019-02-10 11-38

kanishkarj

comment created time in 2 months

PR opened xi-editor/xi-editor

Add Page Up and Page Down

Addresses #698

  • [x] Implement
  • [ ] Test if working
  • [ ] Write tests

I am not sure how to test this. Can someone guide me?

+20 -0

0 comment

3 changed files

pr created time in 3 months

push eventkanishkarj/xi-editor

kanishkarj

commit sha a3ce1c51e2c202c734e2b3babe32348e188f1f7e

Add support for TOML syntax, use for .xiconfig files

view details

kanishkarj

commit sha ddda0d137ab8f08fe805024740cc7d13251a73fd

update toml syntax with metadata

view details

kanishkarj

commit sha 3169c041b8befff3384dc1cc8878128a9a837240

Remove multiple TOML syntax definitions.

view details

Anna Scholtz

commit sha 02b865393c785a77ef6beaced0c15c54e697f674

Automatically delete and load new/modified plugins

view details

Anna Scholtz

commit sha 8fae5f6f5125f41a8a40419b4b16a89d840ead79

Fix formatting

view details

Anna Scholtz

commit sha 233cc66956715f05432814bb6aa96702bb8a78cb

Use cloned() instead of map() and clone()

view details

Rasmus Thomsen

commit sha f81b8a996f088e8d625fe79dee6ffd3859f781ff

Keep existing file perms on saving Also adds accessed_time and creation_time to FileInfo. Adds perms to FileInfo if on unix. fixes #1109

view details

push time in 3 months

create barnchkanishkarj/xi-editor

branch : page-up-down

created branch time in 3 months

push eventkanishkarj/xi-editor

Anna Scholtz

commit sha 02b865393c785a77ef6beaced0c15c54e697f674

Automatically delete and load new/modified plugins

view details

Anna Scholtz

commit sha 8fae5f6f5125f41a8a40419b4b16a89d840ead79

Fix formatting

view details

Anna Scholtz

commit sha 233cc66956715f05432814bb6aa96702bb8a78cb

Use cloned() instead of map() and clone()

view details

Rasmus Thomsen

commit sha f81b8a996f088e8d625fe79dee6ffd3859f781ff

Keep existing file perms on saving Also adds accessed_time and creation_time to FileInfo. Adds perms to FileInfo if on unix. fixes #1109

view details

kanishkarj

commit sha a01ea4018ec724c0004c4f966ba50d0a99d3ad99

Merge branch 'master' of https://github.com/xi-editor/xi-editor into issue-698

view details

push time in 3 months

push eventkanishkarj/xi-editor

kanishkarj

commit sha 464d7bbcdc002023e0d35071a5ae5edfeb0a92ff

Define PageUp and PageDown.

view details

push time in 3 months

create barnchkanishkarj/xi-editor

branch : issue-698

created branch time in 3 months

issue commentxi-editor/xi-editor

Revisit page_up and page_down

I would like to work on this.

cmyr

comment created time in 3 months

startedCogitri/gxi

started time in 3 months

startedxi-editor/xi-editor

started time in 3 months

push eventkanishkarj/xi-editor

kanishkarj

commit sha 5ea865e5235d510a1470acd173ddd052552b1322

Remove multiple TOML syntax definitions.

view details

push time in 3 months

push eventkanishkarj/syntect-resources

kanishkarj

commit sha 158e01eec881f02274b5dbcf3b9ec6ea46f01d00

update toml syntax with metadata

view details

kanishkarj

commit sha 70ce690a9c51e132b4a88a0bf9c993cffdead07b

Remove multiple TOML syntax definitions.

view details

push time in 3 months

push eventkanishkarj/syntect-resources

kanishkarj

commit sha 4729494a27c5f12566ac415482e99e902407d2f4

Remove multiple TOML syntax definitions.

view details

push time in 3 months

pull request commentxi-editor/xi-editor

Add support for TOML syntax, use for .xiconfig files

defaults_meta.packdump updated!

kanishkarj

comment created time in 3 months

push eventkanishkarj/xi-editor

kanishkarj

commit sha d6c61750a90fa3649ffbd2f429d65e5e0c6ac7a4

update toml syntax with metadata

view details

push time in 3 months

pull request commentxi-editor/syntect-resources

update toml syntax with metadata

Hey take a look at this!

kanishkarj

comment created time in 3 months

push eventkanishkarj/syntect-resources

kanishkarj

commit sha 18ea665f10af54c4446e78b1dccb660e6e7d179a

update toml syntax with metadata

view details

push time in 3 months

pull request commentxi-editor/syntect-resources

update toml syntax with metadata

okay.

kanishkarj

comment created time in 3 months

startedxi-editor/syntect-resources

started time in 3 months

push eventkanishkarj/syntect-resources

kanishkarj

commit sha a0d4067e8b71fe2646cfe1e42db13b2d8a6dc67f

Added toml syntax

view details

kanishkarj

commit sha 4efb6c90793ed4540038a13d563c83a35fd0f065

update toml syntax with metadata

view details

push time in 3 months

push eventkanishkarj/syntect-resources

kanishkarj

commit sha de7984a7758d0cb6139176b017de74700f1bd108

update toml syntax with metadata

view details

push time in 3 months

more